home *** CD-ROM | disk | FTP | other *** search
/ Amiga Games: 500 MB Amiga Software / 500 MB Amiga Software - Euber 130 - Amiga Games Disc & Mag.iso / userbox / publicdomain / timeguide / source / t_bestellen.c next >
C/C++ Source or Header  |  1995-10-28  |  78KB  |  2,609 lines
  1. /*********************************************************
  2.  * Time Disk Bestellungsprogramm für die Time.guide        *
  3.  *                (Mein allererstes C Programm)                        *
  4.  *********************************************************
  5.  * Autor:                    Manfred Tremmel                        *
  6.  * Programmiersprache:    C                                            *
  7.  * Compilier:                Maxon C++ (ANSI-C-Modus)            *
  8.  *********************************************************/
  9.  
  10. /* Versionsstring festlegen (fürs Shellkomando Version)    */ 
  11. char VersionID[] = "$VER: T_Bestellen 1.55 (28.10.95)";
  12.  
  13. /* C-Include für String-Operationen                                */
  14. #include <string.h>
  15. #include <stdlib.h>
  16. /* C-Include für Dateioperationen (laden, speichern)        */
  17. #include <stdio.h>
  18.  
  19. /* AMIGA-Includes für die Exec.library                            */
  20. #include <clib/exec_protos.h>
  21. #include <exec/memory.h>
  22. /* AMIGA-Include für die AmigaGuide.library                    */
  23. #include <clib/amigaguide_protos.h>
  24. /* AMIGA-Include für die graphics.library                        */
  25. #include <clib/graphics_protos.h>
  26. /* AMIGA-Include für die intuition.library                    */
  27. #include <clib/intuition_protos.h>
  28. /* AMIGA-Include für die gadtools.library                        */
  29. #include <clib/gadtools_protos.h>
  30. /* AMIGA-Include für die asl.library                            */
  31. #include <clib/asl_protos.h>
  32. /* AMIGA-Include für die locale.library                        */
  33. #include <clib/locale_protos.h>
  34. /* AMIGA-Include für die icon.library                            */
  35. #include <clib/icon_protos.h>
  36. /* AMIGA-Include für die commodities.library                    */
  37. #include <clib/commodities_protos.h>
  38. #include <clib/alib_protos.h>
  39. /* AMIGA-Include für die dos.library zur Dateiüberwachung*/
  40. #include <dos/notify.h>
  41.  
  42. /* AMIGA-Include, das die ganzen pragma/#? included        */
  43. #include <pragma/all_lib.h>
  44.  
  45. /* AMIGA-Include, daß das Programm WB-Startfähig macht    */
  46. #include <workbench/startup.h>
  47. #include <wbstartup.h>
  48.  
  49. /* Texte, die der User zu Gesicht kriegt (via Local-lib.)*/
  50. #include "T_Locale.h"
  51.  
  52. /* Structur für die Intuition.library                            */
  53. struct IntuitionBase    *IntuitionBase        = NULL;
  54. /* Structur für die graphics.library                            */
  55. struct GfxBase            *GfxBase                = NULL;
  56. /* Structur für die gadtools.library                            */
  57. struct Library            *GadToolsBase        = NULL;
  58. /* Structur für die AmigaGuide.library                            */
  59. struct Library            *AmigaGuideBase    = NULL;
  60. /* Structur für die Asl.library                                    */
  61. struct Library            *AslBase                = NULL;
  62. /* Structur für die locale.library                                */
  63. struct LocaleBase        *LocaleBase            = NULL;
  64. /* Structur für die icon.library                                    */
  65. struct IconBase        *IconBase            = NULL;
  66. /* Structur für die commodities.library                        */
  67. struct CxBase            *CxBase                = NULL;
  68. CxObj    *broker, *filter, *sender, *translate;
  69. #define EVT_HOTKEY 1L
  70.  
  71. /* Notify-Structur zur Überwachung der Disk-Datei            */
  72. struct NotifyRequest    *nr;
  73. struct MsgPort            *nmp;
  74. struct NotifyMessage    *nm;
  75.  
  76. /* Signal-Flag-Variablen für die Abfrag eingehender        */
  77. /* Nachrichten (Window und Commodity)                            */
  78. ULONG wndsigflag, cxsigflag;
  79.  
  80. /* Structur für den Asl-Filerequester                            */
  81. struct FileRequester    *fr;
  82. /* Structur für einen einfachen Info-Requester                */
  83. struct EasyStruct        es;
  84.  
  85. /* Dient dazu, eine neue Liste anzulegen                        */
  86. void NewList(struct List *);
  87.  
  88. /* OS 3.x indikator NOS (New Operating System)                */
  89. BOOL NOS = TRUE;
  90. /* Anzahl sichtbarer Einträge im Listview-Gadget            */
  91. /* Unter OS 2.x sind es nur 11 unter 3.x 12 Einträge     */
  92. int  LVSicht = 12;
  93.  
  94. /* Globale Variablen definieren                                    */
  95. /* Einstellungen:                                                        */
  96. struct Einst {
  97.     char AName[30];            /* Absender:    Name                */
  98.     char AStrasse[30];        /* Absender:    Straße            */
  99.     char AOrt[30];                /* Absender:    Ort                */
  100.     char EName[30];            /* Empfänger:    Name                */    
  101.     char EStrasse[30];        /* Empfänger:    Straße            */
  102.     char EOrt[30];                /* Empfänger:    Ort                */
  103.     long Abstand;                /* Druckbeginnabstand            */
  104.     UWORD Versart;                /* Versandart                        */
  105.     char KundNr[30];            /* Absender:    Kundennummer    */
  106. };
  107.  
  108. struct Einst P1;                /* Konkrete Strukt. festlegen    */
  109.  
  110. /* Struktur der Diskettenliste (nur der Diskettenname)    */
  111. struct VDB{
  112.     char Name[16];                /* Diskettennamen                    */
  113. };
  114.  
  115. /* Structur zur Verwaltung der Diskettenliste anlegen        */
  116. struct VDBnode{
  117.     struct    Node n;
  118.     struct    VDB  d;
  119. };
  120.  
  121. /* erzeugt eine Liste, in die die einzelen VDBs kommen    */
  122. struct List vdblist;
  123.  
  124. /* vdblist enthält den aktuellen Eintrag oder NULL            */
  125. struct VDBnode *currentvdb;
  126.  
  127. /* Dateiname des Einstellungs-Files                                */
  128. char Einst_File[128] = "T_Best.dat";
  129.  
  130. /* Datei zwischengemerkter Disketten                            */
  131. char T_Remember[128] = "T:Time_Remember.dat";
  132.  
  133. /* Variablen für das Einbinden als Commodity                    */
  134. BYTE CX_Priority = 0;
  135. BOOL CX_Popup = TRUE;
  136. char CX_Popkey[30] = "ctrl alt t";
  137.  
  138. /* Titel des Fensters                                                */
  139. char WinTitel[50];
  140. /* Funktion GetString holt einen Text aus dem Puffer        */
  141. #define GetString( g )    ((( struct StringInfo * )g->SpecialInfo )->Buffer  )
  142. /* Funktion GetNumber holt eine Nummer aus dem Puffer        */
  143. #define GetNumber( g )    ((( struct StringInfo * )g->SpecialInfo )->LongInt )
  144.  
  145. /* Die Nummern der Gadgets mit konkreten Bezeichnung        */
  146. #define GD_Diskliste        0        /* Diskettenliste                */
  147. #define GD_NeueDisk        1        /* Neu Button                    */
  148. #define GD_DiskLoeschen    2        /* Löschen Button                */
  149. #define GD_Zahlart        3        /* Zahlart MX-Button            */
  150. #define GD_Drucken        4        /* Drucken Button                */
  151. #define GD_Abbrechen        5        /* Abbrechen Button            */
  152. #define GD_AName            6        /* Absender: Name                */
  153. #define GD_AStrasse        7        /* Absender: Strasse            */
  154. #define GD_AOrt            8        /* Absender: Ort                */
  155. #define GD_KundNr            9        /* Kundennummer                */
  156. #define GD_EName            10        /* Empfänger: Name            */
  157. #define GD_EStrasse        11        /* Empfänger: Strasse        */
  158. #define GD_EOrt            12        /* Empfänger: Ort                */
  159. #define GD_DiskAender    13        /* Disk ändern                    */
  160. #define GD_Abstand        14        /* Abstand zum Druckbeginn    */
  161.  
  162. /* Anzahl der Gadgets definieren (0 bis 14 = 15)            */
  163. #define Bestellen_CNT                                    15
  164.  
  165. /* Die Nummern der Menus mit Konkreten Bezeichnungen        */
  166. #define MENU_FOO_OPA        1        /* Öffnen - Einstellungen    */
  167. #define MENU_FOO_OPB        2        /* Öffnen - Diskliste        */
  168. #define MENU_FOO_SPA        3        /* Speichern - Einstell.    */
  169. #define MENU_FOO_SPB        4        /* Speichern - Diskliste    */
  170. #define MENU_FOO_SAA        5        /* Speichern als -Einstell.*/
  171. #define MENU_FOO_SAB        6        /* Speichern als -Diskliste*/
  172. #define MENU_FOO_DRU        7        /* Drucken                        */
  173. #define MENU_FOO_INF        8        /* Information                    */
  174. #define MENU_FOO_HID        9        /* Verbergen                    */
  175. #define MENU_FOO_END        10        /* Ende                            */    
  176.  
  177. /* Screenstruktur löschen                                            */
  178. struct Screen            *Scr = NULL;
  179. /* Public Screen Name löschen                                        */
  180. UBYTE                        *PubScreenName = NULL;
  181. /* DrawInfo deklarieren und löschen                                */
  182. struct DrawInfo        *dri = NULL;
  183. /* VisualInfo löschen                                                */
  184. APTR                        VisualInfo = NULL;
  185. /* Window Struktur löschen                                            */
  186. struct Window            *BestellenWnd = NULL;
  187. /* Gadget Struktur löschen                                            */
  188. struct Gadget            *BestellenGList = NULL;
  189. /* Menu Struktur löschen                                            */
  190. struct Menu                *BestellenMenus = NULL;
  191. /* NewBroker Structur (zur Einbindung als Commodity)        */
  192. struct NewBroker        newbroker = {NULL, NULL, NULL, NULL,
  193.                                     NULL, NULL, NULL, NULL, NULL};
  194.  
  195. /* Anzahl GadgetStrukturen festlegen (15)                        */
  196. struct Gadget            *BestellenGadgets[15];
  197. /* Breite des Fensters (wird nach Fontbreite umgerechnet)*/
  198. UWORD                        BestellenWidth = 460;
  199. /* Höhe des Fenster (wird nach Fonthöhe umgerechnet)        */
  200. UWORD                        BestellenHeight = 250;
  201. /* Struktur Textatribute mit Fontinformationen definieren*/
  202. struct TextAttr        *Font, Attr;
  203. /* Definiere Felder für die Fontbreite und Höhe                */
  204. UWORD                        FontX, FontY;
  205. /* Definiere Felder für den minimalabstand des Fensters    */
  206. UWORD                        OffX, OffY;
  207. /* Definiere Felder für tatsächliche Pos. des Fensters    */
  208. UWORD                        WinX = 0;
  209. UWORD                        WinY = 0;
  210. /* Position im Listview-Gadget                                    */
  211. long                        ListPos = 0;
  212.  
  213. /* Textatribrute für das Fenster                                    */
  214. struct TextFont        *BestellenFont = NULL;
  215.  
  216. /* Texte für das Zahlungsform-MX-Gadget                        */
  217. UBYTE *Gadget300Labels[] = {
  218.     NULL,
  219.     NULL,
  220.     NULL,
  221.     NULL };
  222.  
  223. /* Zusätzliche Texte und deren Position                        */
  224. struct IntuiText BestellenIText[] = {
  225.     1, 0, JAM1,45, 014, NULL, NULL, NULL,
  226.     1, 0, JAM1,45, 132, NULL, NULL, NULL };
  227.  
  228. /* Anzahl zusätzlicher Texte                                        */
  229. #define Bestellen_TNUM 2
  230.  
  231. /* MenuStruktur füllen                                                */
  232. struct NewMenu BestellenNewMenu[] = {
  233.     NM_TITLE, NULL, NULL,    0, 0L, NULL,
  234.      NM_ITEM, NULL, NULL,    0, 0L, NULL,
  235.       NM_SUB, NULL, NULL,    0, 0L, (void *)(MENU_FOO_OPA),
  236.       NM_SUB, NULL, NULL,    0, 0L, (void *)(MENU_FOO_OPB),
  237.      NM_ITEM, NULL, NULL,    0, 0L, NULL,
  238.       NM_SUB, NULL, NULL,    0, 0L, (void *)(MENU_FOO_SPA),
  239.       NM_SUB, NULL, NULL,    0, 0L, (void *)(MENU_FOO_SPB),
  240.      NM_ITEM, NULL, NULL,    0, 0L, NULL,
  241.       NM_SUB, NULL, NULL,    0, 0L, (void *)(MENU_FOO_SAA),
  242.       NM_SUB, NULL, NULL,    0, 0L, (void *)(MENU_FOO_SAB),
  243.      NM_ITEM, NULL, NULL,    0, 0L, (void *)(MENU_FOO_DRU),
  244.      NM_ITEM, (STRPTR)NM_BARLABEL, NULL,    0, 0L, NULL,
  245.      NM_ITEM, NULL, NULL,    0, 0L, (void *)(MENU_FOO_INF),
  246.      NM_ITEM, (STRPTR)NM_BARLABEL, NULL,    0, 0L, NULL,
  247.      NM_ITEM, NULL, NULL,    0, 0L, (void *)(MENU_FOO_HID),
  248.      NM_ITEM, NULL, NULL,    0, 0L, (void *)(MENU_FOO_END),
  249.       NM_END, NULL, NULL,    0, 0L, NULL
  250. };
  251.  
  252. /* Gadgettypen definieren                                            */
  253. UWORD BestellenGTypes[] = {
  254.     LISTVIEW_KIND,
  255.     BUTTON_KIND,
  256.     BUTTON_KIND,
  257.     MX_KIND,
  258.     BUTTON_KIND,
  259.     BUTTON_KIND,
  260.     STRING_KIND,
  261.     STRING_KIND,
  262.     STRING_KIND,
  263.     STRING_KIND,
  264.     STRING_KIND,
  265.     STRING_KIND,
  266.     STRING_KIND,
  267.     STRING_KIND,
  268.     INTEGER_KIND
  269. };
  270.  
  271. /* Gadgets festlegen                                                    */
  272. struct NewGadget BestellenNGad[] = {
  273.     242,  24, 115, 156, NULL, NULL, GD_Diskliste, PLACETEXT_ABOVE, NULL, NULL,
  274.     242, 195,  47,  20, NULL, NULL, GD_NeueDisk, PLACETEXT_IN, NULL, NULL,
  275.     289, 195,  68,  20, NULL, NULL, GD_DiskLoeschen, PLACETEXT_IN, NULL, NULL,
  276.     361,  52,  17,   9, NULL, NULL, GD_Zahlart, PLACETEXT_RIGHT, NULL, NULL,
  277.       4, 225,  88,  20, NULL, NULL, GD_Drucken, PLACETEXT_IN, NULL, NULL,
  278.     366, 225,  88,  20, NULL, NULL, GD_Abbrechen, PLACETEXT_IN, NULL, NULL,
  279.      71,  28, 161,  20, NULL, NULL, GD_AName, PLACETEXT_LEFT, NULL, NULL,
  280.      71,  50, 161,  20, NULL, NULL, GD_AStrasse, PLACETEXT_LEFT, NULL, NULL,
  281.      71,  72, 161,  20, NULL, NULL, GD_AOrt, PLACETEXT_LEFT, NULL, NULL,
  282.      71,  94, 161,  20, NULL, NULL, GD_KundNr, PLACETEXT_LEFT, NULL, NULL,
  283.      71, 147, 161,  20, NULL, NULL, GD_EName, PLACETEXT_LEFT, NULL, NULL,
  284.      71, 169, 161,  20, NULL, NULL, GD_EStrasse, PLACETEXT_LEFT, NULL, NULL,
  285.      71, 191, 161,  20, NULL, NULL, GD_EOrt, PLACETEXT_LEFT, NULL, NULL,
  286.     242, 174, 115,  20, NULL, NULL, GD_DiskAender, 0, NULL, NULL,
  287.     361,  24,  86,  20, NULL, NULL, GD_Abstand, PLACETEXT_ABOVE, NULL, NULL
  288. };
  289.  
  290. /* Tags zu den Gadgets                                                */
  291. ULONG BestellenGTags[] = {
  292.     (GTLV_ShowSelected), 0, (GT_Underscore), '_', (TAG_DONE),
  293.     (GT_Underscore), '_', (TAG_DONE),
  294.     (GT_Underscore), '_', (TAG_DONE),
  295.     (GTMX_Labels), (ULONG)&Gadget300Labels[ 0 ], (GT_Underscore), '_', (TAG_DONE),
  296.     (GT_Underscore), '_', (TAG_DONE),
  297.     (GT_Underscore), '_', (TAG_DONE),
  298.     (STRINGA_ExitHelp), TRUE, (GTST_MaxChars), 29, (GT_Underscore), '_', (TAG_DONE),
  299.     (STRINGA_ExitHelp), TRUE, (GTST_MaxChars), 29, (GT_Underscore), '_', (TAG_DONE),
  300.     (STRINGA_ExitHelp), TRUE, (GTST_MaxChars), 29, (GT_Underscore), '_', (TAG_DONE),
  301.     (STRINGA_ExitHelp), TRUE, (GTST_MaxChars), 29, (GT_Underscore), '_', (TAG_DONE),
  302.     (STRINGA_ExitHelp), TRUE, (GTST_MaxChars), 29, (GT_Underscore), '_', (TAG_DONE),
  303.     (STRINGA_ExitHelp), TRUE, (GTST_MaxChars), 29, (GT_Underscore), '_', (TAG_DONE),
  304.     (STRINGA_ExitHelp), TRUE, (GTST_MaxChars), 29, (GT_Underscore), '_', (TAG_DONE),
  305.     (STRINGA_ExitHelp), TRUE, (GTST_MaxChars), 14, (TAG_DONE),
  306.     (STRINGA_ExitHelp), TRUE, (GTIN_Number), 0, (GTIN_MaxChars), 3, (GT_Underscore), '_', (TAG_DONE)
  307. };
  308.  
  309. /* Vordefinieren sämtlicher im Programm vorkommender        */
  310. /* Unterprogramme                                                        */
  311.  
  312. /* Positionen nach Fontbreite umrechnen                        */
  313. static UWORD ComputeX( UWORD value );
  314.  
  315. /* Positionen nach Fonthöhe umrechnen                            */
  316. static UWORD ComputeY( UWORD value );
  317.  
  318. /* Computerbreite und -höhe Bestimmen                            */
  319. static void ComputeFont( UWORD width, UWORD height );
  320.  
  321. /* Voreinstellungen fürs Fenster (Screen vorbereiten)        */
  322. int SetupScreen( void );
  323.  
  324. /* Sreen wieder zurücksetzen                                        */
  325. void CloseDownScreen( void );
  326.  
  327. /* Texte und BevelBoxes aufs Fenster zeichnen                */
  328. void BestellenRender( void );
  329.  
  330. /* Fenster öffenen                                                    */
  331. int OpenBestellenWindow( void );
  332.  
  333. /* Fenster wieder dicht machen                                    */
  334. void CloseBestellenWindow( void );
  335.  
  336. /*    Gadtools-Gadget einschalten                                     */
  337. void gt_OnGadget( struct Gadget     *gad, struct Window        *w );
  338.  
  339. /*    ...und wieder aus...                                                */
  340. void gt_OffGadget( struct Gadget     *gad, struct Window    *w );
  341.  
  342. /*  String-Gadgets mit nem string füllen                        */
  343. void gt_SetString( struct Gadget    *gad,
  344.                    struct Window    *w,
  345.                    char                *string );
  346.  
  347. /* und nachschaun, welcher drinnen steckt                        */
  348. char * gt_GetString( struct Gadget    *gad );
  349.  
  350. /* Integer-Gadgets mit ner Zahl füllen                            */
  351. void gt_SetInteger( struct Gadget    *gad,
  352.                     struct Window    *w,
  353.                     LONG            value );
  354.  
  355. /* und nachschaun, welche drinnen steckt                        */
  356. LONG gt_GetInteger( struct Gadget    *gad );
  357.  
  358. /* Liste anhängen                                                        */
  359. void gt_AttachList(    struct Gadget     *lv,
  360.                     struct Window     *w,
  361.                      struct List     *list );
  362.  
  363. /* Aktuellen Eintrag setzen                                        */
  364. void gt_SetLV( struct Gadget    *gad,
  365.                struct Window    *w,
  366.                ULONG            value);
  367.  
  368. /* x-ten Eintrag aus einer Exec-Liste holen */
  369. struct Node * gt_GetListEntry( struct List *l,
  370.                                int num );
  371.  
  372. /* Nummer einer Node aus einer Liste feststellen            */
  373. int gt_GetListEntryNum(    struct List *l,
  374.                         struct Node *n );
  375.  
  376. /* Anzahl Einträge einer Liste zählen                            */
  377. int gt_GetListNumEntries( struct List *l );
  378.  
  379. /* Gadgets ein oder Ausschalten                                    */
  380. void checkonoff( void );
  381.  
  382. /* Neuer Eintrag in die Liste    aufnehmen                        */
  383. void newvdb( void );
  384.  
  385. /* Libraries öffnen                                                    */
  386. BOOL OpenAll();
  387.  
  388. /* Libraries schließen                                                */
  389. void CloseAll();
  390.  
  391. /* Unterprogramm zum Einlesen der Einstellungen                */
  392. void EinstLesen();
  393.  
  394. /* Unterprogramm zum Schreiben der Einstellungen            */
  395. void EinstSchreiben();
  396.  
  397. /* Sortiert einen neuen Eintrag in die Liste ein.            */
  398. long NeuerEintrag(char *Eintrag);
  399.  
  400. /* Einen Eintrag aus der Liste entfernen                        */
  401. void EintragLoeschen();
  402.  
  403. /* Unterprogramm zum Einlesen der Time-Diskettendaten        */
  404. void DatenLesen();
  405.  
  406. /* Unterprogramm zum Schreiben der Time-Diskettendaten    */
  407. void DatenSchreiben( struct List *l);
  408.  
  409. /* Die Bestellung auf eine Postkarte Drucken                    */
  410. void Drucken( struct List *l );
  411.  
  412. /* Window mit den Voreingestellten Daten füllen                */
  413. void Winfuell();
  414.  
  415. /* Wenn jemand versucht ein Gadget zu erdrücken                */
  416. BOOL Abfrage_Gadgetup( struct Gadget *gad, long code);
  417.  
  418. /* Jemand hat das Menu benutzt                                    */
  419. BOOL Abfrage_Menuepick( UWORD code);
  420.  
  421. /* Eine handelsübliche Taste wurde gedrückt                    */
  422. BOOL Abfrage_Vanillakey( struct Gadget *gad, UWORD code);
  423.  
  424. /* eine der Tasten die nix aufm Bildschirm hinterlassen    */
  425. void Abfrage_Rawkey( struct Gadget *gad, UWORD code, struct Gadget *gd);
  426.  
  427. /* eine der Tasten die nix aufm Bildschirm hinterlassen    */
  428. void Abfrage_Menuhelp( UWORD code);
  429.  
  430. /* Localisierte Texte einlesen (wenn vorhanden)                */
  431. void LocaleLesen();
  432.  
  433.  
  434. /* Positionen nach Fontbreite umrechnen                        */
  435. static UWORD ComputeX( UWORD value )
  436. {
  437.     return(( UWORD )((( FontX * value ) + 3 ) / (UWORD)7 ));
  438. }
  439.  
  440. /* Positionen nach Fonthöhe umrechnen                            */
  441. static UWORD ComputeY( UWORD value )
  442. {
  443.     return(( UWORD )((( FontY * value ) + 6 ) / (UWORD)12 ));
  444. }
  445.  
  446. /* Computerbreite und -höhe Bestimmen                            */
  447. static void ComputeFont( UWORD width, UWORD height )
  448. {
  449.     /* Voreingestellten Font benutzen                            */
  450.     Font = &Attr;
  451.     /* Fontname bestimmen                                            */
  452.     Font->ta_Name = (STRPTR)Scr->RastPort.Font->tf_Message.mn_Node.ln_Name;
  453.     /* Fonthöhe bestimmen                                            */
  454.     Font->ta_YSize = FontY = Scr->RastPort.Font->tf_YSize;
  455.     /* Fontbreite bestimmen                                            */
  456.     FontX = Scr->RastPort.Font->tf_XSize;
  457.  
  458.     /* minimaler horizontaler Abstand                            */
  459.     OffX = Scr->WBorLeft;
  460.     /* minimaler vertikaler Abstand                                */
  461.     OffY = Scr->RastPort.TxHeight + Scr->WBorTop + 1;
  462.  
  463.     /* Überprüfen, ob das Fenster nicht zu groß wird        */ 
  464.     if ( width && height ) {
  465.         /* Wenn es horizontal zu groß wird, oder                */
  466.         if (( ComputeX( width ) + OffX + Scr->WBorRight ) > Scr->Width )
  467.             goto UseTopaz;
  468.         /* vertikal, dann benutze den Topas 8 Font            */
  469.         if (( ComputeY( height ) + OffY + Scr->WBorBottom ) > Scr->Height )
  470.             goto UseTopaz;
  471.     }
  472.     return;
  473.  
  474. /* Topas Font verwenden, weils Fenster sonst zu groß wird*/
  475. UseTopaz:
  476.     Font->ta_Name = (STRPTR)"topaz.font";
  477.     FontX = FontY = Font->ta_YSize = 8;
  478. }
  479.  
  480. /* Voreinstellungen fürs Fenster (Screen vorbereiten)        */
  481. int SetupScreen( void )
  482. {
  483.     /* Schaun, ob wir nen PubScreen verwenden können        */
  484.     if ( ! ( Scr = LockPubScreen( PubScreenName )))
  485.         return( 1L );
  486.  
  487.     /* Schrifthöhe und -breit bestimmen                            */
  488.     ComputeFont( 0, 0 );
  489.  
  490.     /* Visualinfo setzen (Zeiger, wo es sichtbar wird)        */
  491.     if ( ! ( VisualInfo = GetVisualInfo( Scr, TAG_DONE )))
  492.         return( 2L );
  493.  
  494.     /* wenn alles glatt gegangen ist, 0 zurückgeben            */
  495.     return( 0L );
  496. }
  497.  
  498. /* Sreen wieder zurücksetzen                                        */
  499. void CloseDownScreen( void )
  500. {
  501.     /* falls wir ein VisualInfo gekriegt haben, freigeben    */
  502.     if ( VisualInfo ) {
  503.         FreeVisualInfo( VisualInfo );
  504.         VisualInfo = NULL;
  505.     }
  506.  
  507.     /* PubScreen wieder zurücksetzen                                */
  508.     if ( Scr        ) {
  509.         UnlockPubScreen( NULL, Scr );
  510.         Scr = NULL;
  511.     }
  512. }
  513.  
  514. /* Texte und BevelBoxes aufs Fenster zeichnen                */
  515. void BestellenRender( void )
  516. {
  517.     struct IntuiText    it;
  518.     UWORD            cnt;
  519.  
  520.     /* Font berechnen                                                    */
  521.     ComputeFont( BestellenWidth, BestellenHeight );
  522.  
  523.     /* Absenderumrandende BevelBox zeichnen                    */
  524.     DrawBevelBox( BestellenWnd->RPort, OffX + ComputeX( 10 ),
  525.                     OffY + ComputeY( 24 ),
  526.                     ComputeX( 227 ),
  527.                     ComputeY( 94 ),
  528.                     GT_VisualInfo, VisualInfo, GTBB_Recessed, TRUE, TAG_DONE );
  529.     /* Empfängerumrandende BevelBox zeichnen                    */
  530.     DrawBevelBox( BestellenWnd->RPort, OffX + ComputeX( 10 ),
  531.                     OffY + ComputeY( 143 ),
  532.                     ComputeX( 227 ),
  533.                     ComputeY( 72 ),
  534.                     GT_VisualInfo, VisualInfo, GTBB_Recessed, TRUE, TAG_DONE );
  535.         /* Allumrandende BevelBox zeichnen                            */
  536.     DrawBevelBox( BestellenWnd->RPort, OffX + ComputeX( 2 ),
  537.                     OffY + ComputeY( 3 ),
  538.                     ComputeX( 453 ),
  539.                     ComputeY( 218 ),
  540.                     GT_VisualInfo, VisualInfo, TAG_DONE );
  541.  
  542.     /* Texte ausgeben                                                    */
  543.     for ( cnt = 0; cnt < Bestellen_TNUM; cnt++ ) {
  544.         /* Text aufbereiten                                            */
  545.         CopyMem(( char * )&BestellenIText[ cnt ], ( char * )&it, (long)sizeof( struct IntuiText ));
  546.         /* Font festlegen                                                */
  547.         it.ITextFont = Font;
  548.         /* horizontale Position festlegen                        */
  549.         it.LeftEdge  = OffX + ComputeX( it.LeftEdge ) - ( IntuiTextLength( &it ) >> 1 );
  550.         /* vertikale Position festlegen                            */
  551.         it.TopEdge   = OffY + ComputeY( it.TopEdge ) - ( Font->ta_YSize >> 1 );
  552.         /* Text ausgeben                                                */
  553.         PrintIText( BestellenWnd->RPort, &it, 0, 0 );
  554.     }
  555. }
  556.  
  557. /* Fenster öffenen                                                    */
  558. int OpenBestellenWindow( void )
  559. {
  560.     /* NewGadget Struktur konkret anlegen                        */
  561.     struct NewGadget    ng;
  562.     /* Gadget Struktur konkret anlegen                            */
  563.     struct Gadget    *g;
  564.     /* Zwei laufvariable definieren                                */
  565.     UWORD        lc, tc;
  566.     /* Für die horizontale und vertikale Größe                */
  567.     UWORD        ww, wh;
  568.  
  569.     /* Fontröße berechnen                                            */
  570.     ComputeFont( BestellenWidth, BestellenHeight );
  571.  
  572.     /* absolute Fenstergröße horizontal berechnen            */
  573.     ww = ComputeX( BestellenWidth );
  574.     /* absolute Fenstergröße vertikal berechnen                */
  575.     wh = ComputeY( BestellenHeight );
  576.  
  577.     /* Font öffnen, wenns fehlschlägt, Fehler zurückgeben    */
  578.     if ( ! ( BestellenFont = OpenDiskFont( Font )))
  579.         return( 5L );
  580.  
  581.     /* Liste fürs erstellen der Gadgets erstellen            */
  582.     if ( ! ( g = CreateContext( &BestellenGList )))
  583.         return( 1L );
  584.  
  585.     /* wiederhole, bis alle Gadgets erstellt sind            */
  586.     for( lc = 0, tc = 0; lc < Bestellen_CNT; lc++ )
  587.     {
  588.         /* Speicherbereich in dem die Liste definiert ist    */
  589.         /* an die Liste ranhängen                                    */
  590.         CopyMem((char * )&BestellenNGad[ lc ], (char * )&ng, (long)sizeof( struct NewGadget ));
  591.  
  592.         /* VisualInfo an die Gadgetstructur übergeben        */
  593.         ng.ng_VisualInfo = VisualInfo;
  594.         /* Font fürs Gadget festlegen                                */
  595.         ng.ng_TextAttr   = Font;
  596.         /* horizontale Position errechnen                        */
  597.         ng.ng_LeftEdge   = OffX + ComputeX( ng.ng_LeftEdge );
  598.         /* vertikale Position errechnen                            */
  599.         ng.ng_TopEdge    = OffY + ComputeY( ng.ng_TopEdge );
  600.         /* Breite berechnen                                            */
  601.         ng.ng_Width      = ComputeX( ng.ng_Width );
  602.         /* und die Höhe berechnen                                    */
  603.         ng.ng_Height     = ComputeY( ng.ng_Height);
  604.  
  605.         /* Das ganze können wir jetzt mal herstellen            */
  606.         BestellenGadgets[ lc ] = g = CreateGadgetA((ULONG)BestellenGTypes[ lc ], g, &ng, ( struct TagItem * )&BestellenGTags[ tc ] );
  607.  
  608.         /* tc erhöhen                                                    */
  609.         while( BestellenGTags[ tc ] ) tc += 2;
  610.         tc++;
  611.  
  612.         /* Bei einem Fehler, brechen wir die Sache ab        */
  613.         if ( NOT g )
  614.             return( 2L );
  615.     }
  616.  
  617.     /* Menus noch vorbereiten                                        */
  618.     /* Unter OS 3.x                                                     */
  619.     if( NOS )
  620.     {
  621.         /* Verwenden wir die Prefs-Menü-Farben                    */
  622.         dri = GetScreenDrawInfo( Scr );
  623.         if ( ! ( BestellenMenus = CreateMenus( BestellenNewMenu, GTMN_FrontPen, dri->dri_Pens[BARDETAILPEN], GTMN_NewLookMenus, TRUE, TAG_DONE )))
  624.             return( 3L );
  625.     }
  626.     /* unter OS 2.x                                                    */
  627.     else
  628.     {
  629.         /* können wir standardmäßig die Farbe 0 verwenden    */
  630.         if ( ! ( BestellenMenus = CreateMenus( BestellenNewMenu, GTMN_FrontPen, 0L, TAG_DONE )))
  631.             return( 3L );
  632.     }
  633.  
  634.     /* und herstellen                                                    */
  635.     LayoutMenus( BestellenMenus, VisualInfo, TAG_DONE );
  636.  
  637.     /* Abstand von Oben ermitteln                                    */
  638.     if (WinX > 0)
  639.     {
  640.         if ((WinX + ww + OffX + Scr->WBorRight) > Scr->Width)
  641.         {
  642.             WinX = (Scr->Width - (ww + OffX + Scr->WBorRight));
  643.         }
  644.     }
  645.     else
  646.     {
  647.         WinX = (Scr->Width  - (ww + OffX + Scr->WBorRight )) / (UWORD)2;
  648.     }
  649.  
  650.     /* Abstand von Oben ermitteln                                    */
  651.     if (WinY > 0)
  652.     {
  653.         if ((WinY + wh + OffY + Scr->WBorBottom) > Scr->Height)
  654.         {
  655.             WinY = (Scr->Height - (wh + OffY + Scr->WBorBottom));
  656.         }
  657.     }
  658.     else
  659.     {
  660.         WinY = (Scr->Height - (wh + OffY + Scr->WBorBottom)) / (UWORD)2;
  661.     }
  662.  
  663.     /* Schon können wir es wagen, das Fenster zu öffnen    */
  664.     if ( ! ( BestellenWnd = OpenWindowTags( NULL,
  665.                 WA_Left,                WinX,
  666.                 WA_Top,                WinY,
  667.                 WA_Width,            ww + OffX + Scr->WBorRight,
  668.                 WA_Height,            wh + OffY + Scr->WBorBottom,
  669.                 WA_IDCMP,            IDCMP_CLOSEWINDOW|IDCMP_GADGETUP|IDCMP_GADGETDOWN|IDCMP_MENUHELP|IDCMP_MENUPICK|IDCMP_VANILLAKEY|IDCMP_GADGETHELP|IDCMP_RAWKEY,
  670.                 WA_Flags,            WFLG_DRAGBAR|WFLG_DEPTHGADGET|WFLG_CLOSEGADGET|WFLG_SMART_REFRESH|WFLG_ACTIVATE|WFLG_NEWLOOKMENUS,
  671.                 WA_Gadgets,            BestellenGList,
  672.                 WA_Title,            WinTitel,
  673.                 WA_ScreenTitle,    (UBYTE *)AppStrings[MSG_ScreenName],
  674.                 WA_PubScreen,        Scr,
  675.                 WA_MenuHelp,        TRUE,
  676.                 WA_NewLookMenus,    TRUE,
  677.                 TAG_DONE )))
  678.     return( 4L );
  679.  
  680.     /* Signalbit des Fensters für abfrage merken                */
  681.     wndsigflag = 1L << BestellenWnd->UserPort->mp_SigBit;
  682.     /* Hängen wir das Menu noch dran                                */
  683.     SetMenuStrip( BestellenWnd, BestellenMenus );
  684.     /* Kurzer refresh, sonst schmiert uns das Ding ab        */
  685.     GT_RefreshWindow( BestellenWnd, NULL );
  686.  
  687.     /* Die Bevel Boxen und ein wenig Text draufzeichnen    */
  688.     BestellenRender();
  689.  
  690.     /* Fenster ist offen!                                            */
  691.     CX_Popup = TRUE;
  692.  
  693.     /* Gadgets sperren oder öffnen, wenn nötigt                */
  694.     checkonoff();
  695.  
  696.     /* HelpControl unter 3.x starten, wegen der Hilfe        */
  697.     if( NOS )
  698.     {
  699.         HelpControl(BestellenWnd, HC_GADGETHELP);
  700.     }
  701.  
  702.     /* Alles Klar Boss                                                */
  703.     return( 0L );
  704. }
  705.  
  706. /* Fenster wieder dicht machen                                    */
  707. void CloseBestellenWindow( void )
  708. {
  709.     /* Hat das mit den Menus hingehaun?                            */
  710.     if ( BestellenMenus      )
  711.     {
  712.         /* Vom Fenster abmontieren                                    */
  713.         ClearMenuStrip( BestellenWnd );
  714.         /* und freigeben                                                */
  715.         FreeMenus( BestellenMenus );
  716.         /* Vermerken, daß alles gelöscht wurde                    */
  717.         BestellenMenus = NULL;
  718.     }
  719.  
  720.     /* Konnte das Fenster geöffnet werden                        */
  721.     if ( BestellenWnd        )
  722.     {
  723.         /* Position des Fensters festhalten                        */
  724.         if( !(WinX = BestellenWnd->LeftEdge))
  725.             WinX = 1;
  726.         if( !(WinY = BestellenWnd->TopEdge))
  727.             WinY = 1;
  728.         if ( currentvdb );
  729.             ListPos = gt_GetListEntryNum( &vdblist, (struct Node *) currentvdb );
  730.         /* dann machen wir es wieder zu (wird kalt drausen)*/
  731.         CloseWindow( BestellenWnd );
  732.         /* und vermerken das mal eben                                */
  733.         BestellenWnd = NULL;
  734.         CX_Popup = FALSE;
  735.     }
  736.  
  737.     /* Konnten die Gadgets erzeugt werden                        */
  738.     if ( BestellenGList      )
  739.     {
  740.         /* Befreien wir sie wieder                                    */
  741.         FreeGadgets( BestellenGList );
  742.         /* und vermerken auch dieses                                */
  743.         BestellenGList = NULL;
  744.     }
  745.  
  746.     /* Na, können Sie es sich denken? Konnte der Font...    */
  747.     if ( BestellenFont )
  748.     {
  749.         /* Dann schließen wir auch diesen                        */
  750.         CloseFont( BestellenFont );
  751.         /* und schreibens uns hinter die Löffel                */
  752.         BestellenFont = NULL;
  753.     }
  754. }
  755.  
  756. /*    Gadtools-Gadget einschalten                                     */
  757. void gt_OnGadget( struct Gadget     *gad,
  758.                   struct Window        *w )
  759. {
  760.     GT_SetGadgetAttrs( gad, w, NULL, GA_DISABLED, FALSE, TAG_DONE );
  761. }
  762.  
  763. /*    ...und wieder aus...                                                */
  764. void gt_OffGadget( struct Gadget     *gad,
  765.                    struct Window    *w )
  766. {
  767.     GT_SetGadgetAttrs( gad, w, NULL, GA_DISABLED, TRUE, TAG_DONE );
  768. }
  769.  
  770. /*  String-Gadgets mit nem string füllen                        */
  771. void gt_SetString( struct Gadget    *gad,
  772.                    struct Window    *w,
  773.                    char                *string )
  774. {
  775.     GT_SetGadgetAttrs( gad, w, NULL, GTST_String, string, TAG_DONE );
  776. }
  777.  
  778. /* und nachschaun, welcher drinnen steckt                        */
  779. char * gt_GetString( struct Gadget    *gad )
  780. {
  781.     struct StringInfo *si = gad->SpecialInfo;
  782.  
  783.     if( si )
  784.         return( ( char * ) si->Buffer );
  785.     else
  786.         return( NULL );
  787. }
  788.  
  789. /* Integer-Gadgets mit ner Zahl füllen                            */
  790. void gt_SetInteger( struct Gadget    *gad,
  791.                     struct Window    *w,
  792.                     LONG            value )
  793. {
  794.     GT_SetGadgetAttrs( gad, w, NULL, GTIN_Number, value, TAG_DONE );
  795. }
  796.  
  797. /* und nachschaun, welche drinnen steckt                        */
  798. LONG gt_GetInteger( struct Gadget    *gad )
  799. {
  800.     struct StringInfo *si = gad->SpecialInfo;
  801.  
  802.     if( si )
  803.         return( si->LongInt );
  804.     else
  805.         return( NULL );
  806.  
  807. }
  808.  
  809. /* Listenverwaltung für Listview-Gadgets                        */
  810.  
  811. /* Liste anhängen
  812.  * "list" kann ~0 (-1) sein, dann ist kein Listenzugriff möglich
  813.  */
  814.  
  815. void gt_AttachList(    struct Gadget     *lv,
  816.                     struct Window     *w,
  817.                      struct List     *list )
  818. {
  819.     GT_SetGadgetAttrs( lv, w, NULL, GTLV_Labels, list, TAG_DONE );
  820. }
  821.  
  822. /* Aktuellen Eintrag setzen
  823.  * incl. Automatischem Positionieren, wenn der Eintrag außerhalb
  824.  * des sichtbaren Bereichs ist (maximal 12 Einträge darstellbar)
  825.  */
  826. void gt_SetLV( struct Gadget    *gad,
  827.                struct Window    *w,
  828.                ULONG            value)
  829. {
  830.     ULONG i;
  831.     /* sollte ein Eintrag ausgewählt sein,                        */
  832.     if( value >= 0 )
  833.     {
  834.         /* schau nach, welcher ganz oben in der Liste steht*/
  835.         GT_GetGadgetAttrs( gad, w, NULL, GTLV_Top, &i, TAG_DONE );
  836.         /* ist er größer als der gewählte,                        */
  837.         if(value < i)
  838.         {
  839.             /* dann rutschen wir ein wenig hoch in der Liste*/
  840.             i = value;
  841.             GT_SetGadgetAttrs( gad, w, NULL, GTLV_Top, i, TAG_DONE );
  842.         }
  843.         /* sollte er zu hoch sein,                                    */
  844.         else if((value - i) > (LVSicht - 2))
  845.         {
  846.             /* müssen wir die Liste ein wenig runterblätten    */
  847.             i = value - (LVSicht - 1);
  848.             GT_SetGadgetAttrs( gad, w, NULL, GTLV_Top, i, TAG_DONE );
  849.         }
  850.     }
  851.     /* Nun können der Eintrag ausgewählt werden.                */
  852.     GT_SetGadgetAttrs( gad, w, NULL, GTLV_Selected, value, TAG_DONE );
  853. }
  854.  
  855. /* x-ten Eintrag aus einer Exec-Liste holen */
  856. struct Node * gt_GetListEntry( struct List *l,
  857.                                int num )
  858. {
  859.     int count = 0;
  860.     struct Node *n = l->lh_Head;
  861.  
  862.     while( n->ln_Succ )
  863.     {
  864.         if( num==count ) return( n );
  865.         n = n->ln_Succ;
  866.         count++;
  867.     }
  868.     return( NULL );
  869. }
  870.  
  871. /* Nummer einer Node aus einer Liste feststellen
  872.  * -1 falls nicht in Liste
  873.  */
  874. int gt_GetListEntryNum(    struct List *l,
  875.                         struct Node *n )
  876. {
  877.     int count = 0;
  878.     struct Node *r = l->lh_Head;
  879.  
  880.     while( r->ln_Succ )
  881.     {
  882.         if( r==n ) return( count );
  883.         r = r->ln_Succ;
  884.         count++;
  885.     }
  886.     return( -1 );
  887. }
  888.  
  889. /* Anzahl Einträge einer Liste zählen                            */
  890. int gt_GetListNumEntries( struct List *l )
  891. {
  892.     int count = 0;
  893.     struct Node *n = l->lh_Head;
  894.  
  895.     while( n->ln_Succ )
  896.     {
  897.         n = n->ln_Succ;
  898.         count++;
  899.     }
  900.  
  901.     return( count );
  902. }
  903.  
  904. /* Gadgets ein oder Ausschalten                                    */
  905. void checkonoff( void )
  906. {
  907.     /* Wenn ein Eintrag aus der Liste angewählt ist,        */
  908.     if( currentvdb ) 
  909.     {
  910.         /* schalte die Gadgets ein                                    */
  911.         gt_OnGadget( BestellenGadgets[ GD_DiskLoeschen ], BestellenWnd );
  912.         gt_OnGadget( BestellenGadgets[ GD_DiskAender ], BestellenWnd );
  913.     }
  914.     else
  915.     {
  916.         /* ansonsten brauchen wir sie gerade mal nicht        */
  917.         gt_OffGadget( BestellenGadgets[ GD_DiskLoeschen ], BestellenWnd );
  918.         gt_OffGadget( BestellenGadgets[ GD_DiskAender ], BestellenWnd );
  919.     }
  920. }
  921.  
  922. /* Neuer Eintrag in die Liste    aufnehmen                        */
  923. void newvdb( void )
  924. {
  925.     /* Neue Sturktur anlegen                                        */
  926.     struct VDBnode *new;
  927.  
  928.     /* Speicher dafür reservieren                                    */
  929.     new = AllocVec( sizeof( *new ), MEMF_CLEAR );
  930.  
  931.     /* Nur weitermachen, wenn es geklappt hat                    */
  932.     if( !new )
  933.         return;
  934.  
  935.     /* den neuen Satz zum aktuellen machen                        */
  936.     currentvdb = new;
  937.     new->n.ln_Name = new->d.Name;
  938.  
  939.     /* der neue Satz lautet vorrübergehend "- ??? -"        */
  940.     strcpy( new->d.Name, "- ??? -" );
  941.  
  942.     /* Liste abhängen                                                    */
  943.     gt_AttachList( BestellenGadgets[GD_Diskliste], BestellenWnd, (struct List *) ~0 );
  944.  
  945.     /* Priorität = ASCII-Wert des ersten Buchstaben            */
  946.     new->n.ln_Pri     = - new->d.Name[0];
  947.  
  948.     /* an die Liste nach Prioritäten sortiert anhängen        */    
  949.     Enqueue( &vdblist, (struct Node *) new );
  950.  
  951.     /* geänderte Liste wieder anhängen                            */
  952.     gt_AttachList( BestellenGadgets[GD_Diskliste], BestellenWnd, &vdblist );
  953.  
  954.     /* im ListviewGadget aktivieren                                */
  955.     gt_SetLV(BestellenGadgets[GD_Diskliste], BestellenWnd, gt_GetListEntryNum(&vdblist, (struct Node *) new));
  956.  
  957.     /* Wenn die Gadgets abgeschaltet sind, einschalten        */
  958.     checkonoff();
  959.  
  960.     /* den "- ??? -" ins String Gadget schreiben und zur    */
  961.     gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, currentvdb->d.Name );
  962.  
  963.     /* Änderung aktivieren, oder wollen Sie eine Test Disk*/
  964.     ActivateGadget( BestellenGadgets[GD_DiskAender], BestellenWnd, NULL );
  965. }
  966.  
  967. /* Libraries öffnen                                                    */
  968. BOOL OpenAll()
  969. {
  970.     /* Kick 2.0 muß vorhanden sein                                */
  971.     /* Library-Versionen mind. 37                                    */
  972.  
  973.     /* Intuition.library in der 37er Version öffnen (3.x)    */
  974.     IntuitionBase = (struct IntuitionBase *)
  975.         OpenLibrary("intuition.library",37L);
  976.  
  977.     /* Graphics.library öffnen                                        */
  978.     GfxBase = (struct GfxBase *)
  979.         OpenLibrary("graphics.library",37L);
  980.  
  981.     /* GadTools.library öffnen                                        */
  982.    GadToolsBase = (struct Library *)
  983.         OpenLibrary("gadtools.library",37L);
  984.  
  985.     /* Wenn das geklappt hat                                        */
  986.     if( GadToolsBase )
  987.     {
  988.         /* OS 3.0 (V39) oder höher vorhanden?                    */
  989.         if( (GadToolsBase->lib_Version) > 38U )
  990.         {
  991.             NOS = TRUE;
  992.             LVSicht = 12;
  993.         }
  994.         else
  995.         {
  996.             NOS = FALSE;
  997.             LVSicht = 11;
  998.         }
  999.     }
  1000.  
  1001.     /* Asl.library öffnen (nicht zwindend notwendig)        */
  1002.     AslBase       =
  1003.         OpenLibrary("asl.library", 37L);
  1004.  
  1005.     /* AmigaGuide.library (nicht zwingend notwendig)        */
  1006.     AmigaGuideBase =
  1007.         OpenLibrary("amigaguide.library", 0L);
  1008.  
  1009.     /* Locale.library (nicht zwingend notwendig)                */
  1010.     LocaleBase = (struct LocaleBase *)
  1011.         OpenLibrary("locale.library", 38L);
  1012.  
  1013.     /* Icon.library (nicht zwingend notwendig)                */
  1014.     IconBase = (struct IconBase *)
  1015.         OpenLibrary("icon.library", 37L);
  1016.  
  1017.     /* Commodities.library öffnen                                    */
  1018.     CxBase = (struct CxBase *)
  1019.         OpenLibrary("commodities.library", 37L);
  1020.  
  1021.     /* Hat es nicht geklappt, Fehler zurückgeben                */
  1022.     if(! CxBase            ||
  1023.         ! GadToolsBase    ||
  1024.         ! GfxBase        ||
  1025.         ! IntuitionBase)
  1026.         return FALSE;
  1027.     return TRUE;
  1028. }
  1029.  
  1030. /* Libraries schließen                                                */
  1031. void CloseAll()
  1032. {
  1033.     /* locale.library schließen, wenn sie offen ist            */
  1034.     if( CxBase )
  1035.         CloseLibrary( ( struct Library *)CxBase );
  1036.     /* Icon.library schließen, wenn sie offen ist            */
  1037.     if( IconBase )
  1038.         CloseLibrary( ( struct Library *)IconBase );
  1039.     /* locale.library schließen, wenn sie offen ist            */
  1040.     if( LocaleBase )
  1041.         CloseLibrary( ( struct Library *)LocaleBase );
  1042.     /* AmigaGuide.library schließen, wenn sie offen ist    */
  1043.     if( AmigaGuideBase )
  1044.         CloseLibrary( ( struct Library *)AmigaGuideBase );
  1045.     /* Asl.library schließen, wenn sie offen ist                */
  1046.     if( AslBase )
  1047.         CloseLibrary( ( struct Library *)AslBase );
  1048.     /* GadTools.library schließen, wenn sie offen ist        */
  1049.     if( GadToolsBase )
  1050.         CloseLibrary( ( struct Library *)GadToolsBase );
  1051.     /* Graphics.library schließen, wenn sie offen ist        */
  1052.     if( GfxBase )
  1053.         CloseLibrary( ( struct Library *)GfxBase );
  1054.     /* Intuition.library schließen, wenn sie offen ist        */
  1055.     if( IntuitionBase )
  1056.         CloseLibrary( ( struct Library *)IntuitionBase );
  1057.     return;
  1058. }
  1059.  
  1060. /* Unterprogramm zum Einlesen der Einstellungen                */
  1061. void EinstLesen()
  1062. {
  1063.     /* Datei öffnen                                                    */
  1064.     BPTR is;
  1065.     is = Open(Einst_File,MODE_OLDFILE);
  1066.     /* Wenn das geklappt hat,                                        */
  1067.     if(is)
  1068.     {
  1069.         /* lies die Einstellungen                                    */
  1070.         Read(is, &P1, sizeof( P1 ));
  1071.         /* Schließ die Datei wieder                                */
  1072.         Close(is);
  1073.     }
  1074. }
  1075.  
  1076. /* Unterprogramm zum Schreiben der Einstellungen            */
  1077. void EinstSchreiben()
  1078. {
  1079.     /* Datei öffnen                                                    */
  1080.     BPTR os;
  1081.     os = Open(Einst_File, MODE_NEWFILE);
  1082.     /* Wenn das geklappt hat,                                        */
  1083.     if(os)
  1084.     {
  1085.         /* schreib die Einstellungen                                */
  1086.         Write(os, &P1, sizeof( P1 ));
  1087.         /* Schließ die Datei wieder                                */
  1088.         Close(os);
  1089.     }
  1090. }
  1091.  
  1092. /* Sortiert einen neuen Eintrag in die Liste ein.            */
  1093. long NeuerEintrag(char *Eintrag)
  1094. {
  1095.     long Entries;
  1096.     long i;
  1097.     struct VDBnode *n;
  1098.     struct VDBnode *m;
  1099.  
  1100.     /* Anzahl der bereits existierenden Eintragungen        */
  1101.     Entries = gt_GetListNumEntries( &vdblist );
  1102.  
  1103.     /* Schleife vom Ende bis zum Anfang der Liste            */
  1104.     for( i = Entries-1; i >= 0; i--) 
  1105.     {
  1106.         /* Eintrag aus der Liste Holen                            */
  1107.         m = (struct VDBnode *) gt_GetListEntry( &vdblist, i );
  1108.  
  1109.         /* Der Eintrag ist bereits vorhanden -> ignorieren    */
  1110.         if(strcmp(m->d.Name, Eintrag)==0)
  1111.             return i;
  1112.  
  1113.         /* Die richtige Stelle wurde gefunden -> Einfügen    */
  1114.         if(strcmp(m->d.Name, Eintrag)<0)
  1115.         {
  1116.             /* Speicher alokieren                                    */
  1117.             n = AllocVec( sizeof( *n ), MEMF_CLEAR );
  1118.             if( n )
  1119.             {
  1120.                 /* die ganze Sache aufbereiten                    */
  1121.                 strcpy(n->d.Name, Eintrag);
  1122.                 n->n.ln_Name = n->d.Name;
  1123.                 n->n.ln_Pri  = - n->d.Name[0];
  1124.                 /* und dahinter anhängen                            */
  1125.                 Insert( &vdblist, (struct Node *) n, (struct Node *) m );
  1126.             }
  1127.             /* Eingefügte Pos. = i+1, das geben wir zurück    */
  1128.             return ++i;
  1129.         }
  1130.     }
  1131.  
  1132.     /* Kein kleinerer Eintrag gefunden?                            */
  1133.     n = AllocVec( sizeof( *n ), MEMF_CLEAR );
  1134.     if( n )
  1135.     {
  1136.         /* die ganze Sache aufbereiten                            */
  1137.         strcpy(n->d.Name, Eintrag);
  1138.         n->n.ln_Name = n->d.Name;
  1139.         n->n.ln_Pri  = - n->d.Name[0];
  1140.         /* dann setz ihn vorne dran                                */
  1141.         AddHead( &vdblist, (struct Node *) n );
  1142.     }
  1143.     /* Eingefügte Position = 0, das geben wir zurück        */
  1144.     return 0;
  1145. }
  1146.  
  1147. /* Einen Eintrag aus der Liste entfernen                        */
  1148. void EintragLoeschen()
  1149. {
  1150.     long i;
  1151.     /* Wenn ein Eintrag ausgewählt ist                            */
  1152.     if(currentvdb)
  1153.     {
  1154.         /* Die Nummer des Eintrags bestimmen                    */
  1155.         i = gt_GetListEntryNum(&vdblist, (struct Node *) currentvdb);
  1156.         /* Ist diese > 0, wird der nächste Eintrag eins kl.*/
  1157.         if(i > 0)
  1158.             i--;
  1159.         /* Ansonsten 0 (der Beginn der Liste)                    */
  1160.         else
  1161.             i = 0;
  1162.         /* Liste abhängen                                                */
  1163.         gt_AttachList( BestellenGadgets[ GD_Diskliste ], BestellenWnd, (struct List *) ~0 );
  1164.         /* Den Eintrag entfernen                                    */
  1165.         Remove( (struct Node *) currentvdb );
  1166.         /* ebenso den passenden Vektor                            */
  1167.         FreeVec( currentvdb );
  1168.         /* Liste wieder anhängen                                    */
  1169.         gt_AttachList( BestellenGadgets[ GD_Diskliste ], BestellenWnd, &vdblist );
  1170.         /* Neuer aktueller Eintrag (wenn Liste nicht leer)    */
  1171.         if (IsListEmpty( &vdblist ))
  1172.         {
  1173.             currentvdb = NULL;
  1174.             /* Feld darunter löschen                                */
  1175.             gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, "");
  1176.         }
  1177.         else
  1178.         {
  1179.             currentvdb = (struct VDBnode *) gt_GetListEntry( &vdblist, i );
  1180.             /* Neuen aktuellen Eintag in der Liste auswählen*/
  1181.             gt_SetLV( BestellenGadgets[ GD_Diskliste ], BestellenWnd, i );
  1182.             /* und im Feld darunter anzeigen                        */
  1183.             gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, currentvdb->d.Name );
  1184.         }
  1185.         /* Wenn keiner mehr drinnen ist, Gad. abschalten    */
  1186.         checkonoff();
  1187.     }
  1188. }
  1189.  
  1190. /* Unterprogramm zum Einlesen der Time-Diskettendaten        */
  1191. void DatenLesen()
  1192. {
  1193.     FILE *is;
  1194.     char lespuf[16];
  1195.  
  1196.     /* Liste initialisieren                                            */
  1197.     NewList( &vdblist );
  1198.     /* Bei Beginn noch keinen aktuellen Eintrag                */
  1199.     currentvdb = NULL;
  1200.  
  1201.     /* Datei öffnen zum lesen (read -> "r")                    */
  1202.     is = fopen(T_Remember, "r");
  1203.     if(is)
  1204.     {
  1205.         /* Solange was in der Datei steckt, lesen                */
  1206.         while(fgets(lespuf, 15, is))
  1207.         {
  1208.             /* und an die Liste dranhängen                        */
  1209.             NeuerEintrag(lespuf);
  1210.         }
  1211.         /* Hinterher die Datei wieder dicht machen            */
  1212.         fclose(is);
  1213.     }
  1214. }
  1215.  
  1216. /* Unterprogramm zum Schreiben der Time-Diskettendaten    */
  1217. void DatenSchreiben( struct List *l )
  1218. {
  1219.     int i = 0;
  1220.     struct Node *n = l->lh_Head;
  1221.     struct VDBnode *a;
  1222.     FILE *os;
  1223.  
  1224.     /* Datei zum Schreiben öffnen (write -> "w")                */
  1225.     os = fopen(T_Remember, "w");
  1226.     /* Hat das öffnen hingehauen                                    */
  1227.     if(os)
  1228.     {
  1229.         /* Die Liste von Anfang bis Schluß durchackern    */
  1230.         while( n->ln_Succ )
  1231.         {
  1232.             n = n->ln_Succ;
  1233.             a = (struct VDBnode *) gt_GetListEntry( &vdblist, i );
  1234.             i++;
  1235.             /* Disknamen reinschreiben                            */
  1236.             fputs( a->d.Name, os );
  1237.             fputc( '\n', os);
  1238.         }
  1239.         /* Wenns öffnen geklappt hat, dann Datei schließ*/
  1240.         fclose(os);
  1241.     }
  1242. }
  1243.  
  1244. /* Die Bestellung auf eine Postkarte Drucken                    */
  1245. void Drucken( struct List *l )
  1246. {
  1247.     /* Einen Schreibpuffer für die aufbereiten der Zeilen    */
  1248.     char Schreibpuf[1000];
  1249.     char Zeilenpuf[60];
  1250.     char i;
  1251.     struct VDBnode *a;
  1252.     struct Node *n = l->lh_Head;
  1253.  
  1254.     FILE *os;
  1255.     /* Requester vorbereiten                                        */
  1256.     es.es_StructSize    = sizeof(struct EasyStruct);
  1257.     es.es_Flags            = 0;
  1258.  
  1259.     /* Datei zum drucken oder speichern öffnen                */
  1260.     os = fopen("PRT:", "w");
  1261.     /* Hats geklappt?                                                    */
  1262.     if(os)
  1263.     {
  1264.         /* Requester zur Aufford. die Postkarte einzul.        */
  1265.         es.es_Title            = AppStrings[MSG_DruReqTitel];
  1266.         es.es_TextFormat    = AppStrings[MSG_DruReqText1];
  1267.         es.es_GadgetFormat= AppStrings[MSG_DruReqWahl];
  1268.  
  1269.         /* Wenn er mit Drucken bestätigt wurde    i > 0            */
  1270.         i = EasyRequest(BestellenWnd, &es, NULL);
  1271.  
  1272.         /* Falls i > 0 drucken/speichern                            */
  1273.         if(i)
  1274.         {
  1275.             strcpy(Schreibpuf, '\0');
  1276.             /* Die Leerzeilen zu Beginn einfügen                */
  1277.             for( i = 0; i < P1.Abstand; i++)
  1278.             {
  1279.                 strcat(Schreibpuf, "\n")
  1280.             }
  1281.             /* Die Zeile mit dem Absendernamen drucken und    */
  1282.             strcat(Schreibpuf, "  ");
  1283.             strcat(Schreibpuf, P1.AName);
  1284.             strcat(Schreibpuf, "\n\n");
  1285.             /* Die Zeile mit der Kundennummer drucken und    */
  1286.             strcat(Schreibpuf, AppStrings[MSG_DruText0]);
  1287.             strcat(Schreibpuf, P1.KundNr);
  1288.             strcat(Schreibpuf, "\n\n");
  1289.             /* Die Zeile mit der Absenderstraße drucken und    */
  1290.             strcat(Schreibpuf, "  ");
  1291.             strcat(Schreibpuf, P1.AStrasse);
  1292.             strcat(Schreibpuf, "\n\n");
  1293.             /* Die Zeile mit dem Absenderort drucken und        */
  1294.             strcat(Schreibpuf, "  ");
  1295.             strcat(Schreibpuf, P1.AOrt);
  1296.             strcat(Schreibpuf, "\n\n");
  1297.             /* Die Zeile mit dem Empfängernamen drucken und    */
  1298.             strcat(Schreibpuf, "                             ");
  1299.             strcat(Schreibpuf, P1.EName);
  1300.             strcat(Schreibpuf, "\n\n\n\n");
  1301.             /* Die Zeile mit der Empf.straße drucken und        */
  1302.             strcat(Schreibpuf, "                             ");
  1303.             strcat(Schreibpuf, P1.EStrasse);
  1304.             strcat(Schreibpuf, "\n\n\n\n");
  1305.             /* zuguterletzt den Empfängerort drucken und        */
  1306.             strcat(Schreibpuf, "                             ");
  1307.             strcat(Schreibpuf, P1.EOrt);
  1308.             strcat(Schreibpuf, "\f");
  1309.             if (fputs( Schreibpuf, os ) == DOSTRUE)
  1310.             {
  1311.                 /* Schreiben klappte nicht                            */
  1312.                 es.es_Title            = AppStrings[MSG_ErrorReqTitel];
  1313.                 es.es_TextFormat    = AppStrings[MSG_ErrorReqText1];
  1314.                 es.es_GadgetFormat= AppStrings[MSG_ErrorReqWahl];
  1315.  
  1316.                 EasyRequest(BestellenWnd, &es, NULL);
  1317.                 os = NULL;
  1318.             }
  1319.         }
  1320.         /* und schließe die Datei wieder                            */
  1321.         fclose(os);
  1322.     }
  1323.  
  1324.     /* Datei zum drucken oder speichern öffnen                */
  1325.     os = fopen("PRT:", "w");
  1326.     /* Hats geklappt?                                                    */
  1327.     if(os)
  1328.     {
  1329.         /* Die Aufforderung, die Postkarte umzudrehen        */
  1330.         es.es_Title            = AppStrings[MSG_DruReqTitel];
  1331.         es.es_TextFormat    = AppStrings[MSG_DruReqText2];
  1332.         es.es_GadgetFormat= AppStrings[MSG_DruReqWahl];
  1333.  
  1334.         /* Wenn er mit Drucken bestätigt wurde                    */
  1335.         i = EasyRequest(BestellenWnd, &es, NULL);
  1336.  
  1337.         /* Wenn i > 0                                                    */
  1338.         if(i)
  1339.         {
  1340.             strcpy(Schreibpuf, '\0');
  1341.             /* Die Leerzeilen zu Beginn einfügen                */
  1342.             for( i = 0; i < P1.Abstand; i++)
  1343.             {
  1344.                 strcat(Schreibpuf, "\n")
  1345.             }
  1346.             /* Ein Text, der klar macht, was wir wollen        */
  1347.             strcat(Schreibpuf, AppStrings[MSG_DruText1]);
  1348.             /* Nachschaun, welche Zahlungsart aktuell ist    */
  1349.             switch( P1.Versart )
  1350.             {
  1351.                 /* Nachnahme,                                            */
  1352.                 case 0:
  1353.                     strcat(Schreibpuf, AppStrings[MSG_DruText2]);
  1354.                     break;
  1355.                 /* Vorkasse oder                                        */
  1356.                 case 1:
  1357.                     strcat(Schreibpuf, AppStrings[MSG_DruText3]);
  1358.                     break;
  1359.                 /* gegen Rechnung                                        */
  1360.                 default:
  1361.                     strcat(Schreibpuf, AppStrings[MSG_DruText4]);
  1362.                     break;
  1363.             }
  1364.             strcpy(Zeilenpuf, "  ");
  1365.             i = 0;
  1366.             /* Nun zu den Disketten selbst                        */
  1367.             while( n->ln_Succ )
  1368.             {
  1369.                 /* Zunächst holen wir mal die Diskbezeichn.,    */
  1370.                 n = n->ln_Succ;
  1371.                 a = (struct VDBnode *) gt_GetListEntry( &vdblist, i );
  1372.                 i++;
  1373.                 /* schaun ob in der Zeile noch Platz ist,        */
  1374.                 if((strlen(a->d.Name) + strlen(Zeilenpuf)) > 52 )
  1375.                 {
  1376.                     /* wenn nicht, drucken wir die alte und    */
  1377.                     strcat( Schreibpuf, Zeilenpuf );
  1378.                     strcat( Schreibpuf, "\n");
  1379.                     /* beginnen eine neue                            */
  1380.                     strcpy(Zeilenpuf, "  ");
  1381.                 }
  1382.                 /* nun können wir getrost die Diskettenbez.    */
  1383.                 strcat(Zeilenpuf, a->d.Name);
  1384.                 /* gefolgt von einem Komma dranhängen            */
  1385.                 strcat(Zeilenpuf, ", ");
  1386.             }
  1387.             /* Da die letzte Zeile nicht gedruckt wurde,        */
  1388.             /* holen wir das nach und                                */
  1389.             strcat( Schreibpuf, Zeilenpuf );
  1390.             /* hängen eine Leerzeile dran.                        */
  1391.             strcat( Schreibpuf, "\n\n" );
  1392.             /* In der Hoffnung das es auch wirklich flott    */
  1393.             /* geht, danken wir dafür schon im Voraus,        */
  1394.             strcat(Schreibpuf, AppStrings[MSG_DruText5]);
  1395.             if (fputs( Schreibpuf, os ) == DOSTRUE)
  1396.             {
  1397.                 /* Schreiben klappte nicht                            */
  1398.                 es.es_Title            = AppStrings[MSG_ErrorReqTitel];
  1399.                 es.es_TextFormat    = AppStrings[MSG_ErrorReqText1];
  1400.                 es.es_GadgetFormat= AppStrings[MSG_ErrorReqWahl];
  1401.  
  1402.                 EasyRequest(BestellenWnd, &es, NULL);
  1403.             }
  1404.         }
  1405.         /* und schließen die Datei wieder                        */
  1406.         fclose(os);
  1407.     }
  1408.     /* Konnte die Datei jedoch nicht geöffnet werden,        */
  1409.     else
  1410.     {
  1411.         /* wird der Benuter per Requester Informiert            */
  1412.         es.es_Title            = AppStrings[MSG_ErrorReqTitel];
  1413.         es.es_TextFormat    = AppStrings[MSG_ErrorReqText2];
  1414.         es.es_GadgetFormat= AppStrings[MSG_ErrorReqWahl];
  1415.  
  1416.         EasyRequest(BestellenWnd, &es, NULL);
  1417.     }
  1418. }
  1419.  
  1420. /* Window mit den Voreingestellten Daten füllen                */
  1421. void Winfuell()
  1422. {
  1423.     /* Daten in das ListView Gadget einbauen                    */
  1424.     gt_AttachList( BestellenGadgets[GD_Diskliste], BestellenWnd, &vdblist );
  1425.  
  1426.     /* Voreinstellungen einbauen                                    */
  1427.     GT_SetGadgetAttrs( BestellenGadgets[ GD_Zahlart ], BestellenWnd, NULL, 
  1428.                                 GTMX_Active, P1.Versart,
  1429.                                 TAG_DONE);
  1430.     gt_SetString( BestellenGadgets[ GD_AName ], BestellenWnd, P1.AName );
  1431.     gt_SetString( BestellenGadgets[ GD_AStrasse ], BestellenWnd, P1.AStrasse);
  1432.     gt_SetString( BestellenGadgets[ GD_AOrt ], BestellenWnd, P1.AOrt);
  1433.     gt_SetString( BestellenGadgets[ GD_KundNr ], BestellenWnd, P1.KundNr );
  1434.  
  1435.     gt_SetString( BestellenGadgets[ GD_EName ], BestellenWnd, P1.EName );
  1436.     gt_SetString( BestellenGadgets[ GD_EStrasse ], BestellenWnd, P1.EStrasse);
  1437.     gt_SetString( BestellenGadgets[ GD_EOrt ], BestellenWnd, P1.EOrt);
  1438.  
  1439.     gt_SetInteger( BestellenGadgets[ GD_Abstand ], BestellenWnd, P1.Abstand);
  1440.     /* momentan nicht benötigte Gadgets sperren                */
  1441.     checkonoff();
  1442. }
  1443.  
  1444. /* Wenn jemand versucht ein Gadget zu erdrücken                */
  1445. BOOL Abfrage_Gadgetup( struct Gadget *gad, long code)
  1446. {
  1447.     char Merken[15];
  1448.     long i = 0;
  1449.     BOOL terminated = FALSE;    
  1450.  
  1451.     /* Wenn die Help-Taste der Grund fürs Beenden des G.    */
  1452.     if(code==95)
  1453.     {
  1454.         /* Rufen wir die Rawkey-Abfrage auf (HELP-Behandl.)*/
  1455.         Abfrage_Rawkey(gad,code,gad);
  1456.         /* mehr gibts nicht zu tun, also ab nach Hause        */
  1457.         return terminated;
  1458.     }
  1459.  
  1460.     /* mal sehen, auf welches G. der User es abgesehen hat*/
  1461.     switch( gad->GadgetID )
  1462.     {
  1463.         /* Jemand hat auf die Liste geklickt                    */
  1464.         case GD_Diskliste:
  1465.             /* dann gibts einen neuen aktuellen Eintrag        */
  1466.             currentvdb = (struct VDBnode *) gt_GetListEntry( &vdblist, code );
  1467.             /* eventuell gesperrte Gadgets freigeben            */
  1468.             checkonoff();
  1469.             /* Stringgadget unter der Liste füllen                */
  1470.             gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, currentvdb->d.Name );
  1471.             /* und aktivieren                                            */
  1472.             ActivateGadget( BestellenGadgets[GD_DiskAender], BestellenWnd, NULL );
  1473.             break;
  1474.  
  1475.         /* Jemand will ne neue Disk eingeben                    */
  1476.         case GD_NeueDisk:
  1477.             /* Dafür haben wir ein Unerprogramm                    */
  1478.             newvdb();
  1479.             break;
  1480.  
  1481.         /* Jemand will ne Disk löschen                            */
  1482.         case GD_DiskLoeschen:
  1483.             /* auch dafür gibts ein Unterprogramm                */
  1484.             EintragLoeschen();
  1485.             break;
  1486.         /* Zahlart wurde geändert                                    */
  1487.         case GD_Zahlart:
  1488.             /* einfach nur merken, das reicht schon            */
  1489.             P1.Versart = code;
  1490.             break;
  1491.         /* Drucken                                                        */
  1492.         case GD_Drucken:
  1493.             /* Druckroutine aufrufen                                */
  1494.             Drucken(&vdblist);
  1495.             break;
  1496.         /* Abbrechen                                                    */
  1497.         case GD_Abbrechen:
  1498.             /* zurückgeben, daß der User keine Lust mer hat    */
  1499.             terminated = TRUE;
  1500.             break;
  1501.         /* Absendername                                                */
  1502.         case GD_AName:
  1503.             /* Einfach nur den neuen Namen merken                */
  1504.             strcpy( P1.AName, gt_GetString( BestellenGadgets[ GD_AName ]) );
  1505.             break;
  1506.         /* Absenderstraße                                                */
  1507.         case GD_AStrasse:
  1508.             /* Einfach nur die neue Straße merken                */
  1509.             strcpy( P1.AStrasse, gt_GetString( BestellenGadgets[ GD_AStrasse ]) );
  1510.             break;
  1511.         /* Absenderort                                                    */
  1512.         case GD_AOrt:
  1513.             /* Einfach nur den Ort merken                            */
  1514.             strcpy( P1.AOrt, gt_GetString( BestellenGadgets[ GD_AOrt ]) );
  1515.             break;
  1516.         /* Kundennummer                                                */
  1517.         case GD_KundNr:
  1518.             /* Einfach nur die Kundennummer merken                */
  1519.             strcpy( P1.KundNr, gt_GetString( BestellenGadgets[ GD_KundNr ]) );
  1520.             break;
  1521.         /* Empfängername                                                */
  1522.         case GD_EName:
  1523.             /* Einfach nur den Namen merken                        */
  1524.             strcpy( P1.EName, gt_GetString( BestellenGadgets[ GD_EName ]) );
  1525.             break;
  1526.         /* Empfängerstrasse                                            */
  1527.         case GD_EStrasse:
  1528.             /* Einfach nur die Strasse merken                    */
  1529.             strcpy( P1.EStrasse, gt_GetString( BestellenGadgets[ GD_EStrasse ]) );
  1530.             break;
  1531.         /* Empfängerort                                                */
  1532.         case GD_EOrt:
  1533.             /* Einfach nur den Ort merken                            */
  1534.             strcpy( P1.EOrt, gt_GetString( BestellenGadgets[ GD_EOrt ]) );
  1535.             break;
  1536.         /* Diskette neu angelegt oder alte ändern                */
  1537.         case GD_DiskAender:
  1538.             /* Den neuen Namen Merken                                */
  1539.             strcpy(Merken, gt_GetString( BestellenGadgets[ GD_DiskAender ]) );
  1540.             /* Wenn er sich nicht geändert hat, ignorieren    */
  1541.             if(strcmp(currentvdb->d.Name, Merken)==0) {}
  1542.             /* aber sonst                                                */
  1543.             else
  1544.             {
  1545.                 /* löschen wir den alten Eintrag                    */
  1546.                 EintragLoeschen();
  1547.                 /* Hängen die Liste ab                                */
  1548.                 gt_AttachList( BestellenGadgets[GD_Diskliste], BestellenWnd, (struct List *) ~0 );
  1549.                 /* den neuen Eintrag an (Position merken)        */
  1550.                 i = NeuerEintrag( Merken );
  1551.                 /* hängen die Liste wieder dran                    */
  1552.                 gt_AttachList( BestellenGadgets[GD_Diskliste], BestellenWnd, &vdblist );
  1553.                 /* aktivieren den neuen Eintrag                    */
  1554.                 gt_SetLV( BestellenGadgets[GD_Diskliste], BestellenWnd, i );
  1555.                 /* merken ihn uns als aktuellen                    */
  1556.                 currentvdb = (struct VDBnode *) gt_GetListEntry( &vdblist, i );
  1557.                 /* schalten alle Gadgets an und                    */
  1558.                 checkonoff();
  1559.                 /* setzen den Namen ins Feld unter der Liste    */
  1560.                 gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, currentvdb->d.Name );
  1561.             }
  1562.             break;
  1563.         /* Abstand fürs Drucken                                        */
  1564.         case GD_Abstand:
  1565.             /* Den Abstand einfach nur merken                    */
  1566.             P1.Abstand = gt_GetInteger( BestellenGadgets[ GD_Abstand ]);
  1567.             break;
  1568.         /* Dürfte nicht vorkommen, aber sicher ist sicher!    */
  1569.         default:
  1570.             break;
  1571.     }
  1572.     /* Und ab nach Hause, mit Rückgabewert, ob Schluß ist    */
  1573.     return(terminated);
  1574. }
  1575.  
  1576. /* Jemand hat das Menu benutzt                                    */
  1577. BOOL Abfrage_Menuepick( UWORD code)
  1578. {
  1579.     /* Struktur für den Requester, falls wir ihn brauchen    */
  1580.     char Verzeichnis[128];
  1581.     struct MenuItem *item;
  1582.     struct VDBnode *n;
  1583.     unsigned i;
  1584.     BOOL terminated = FALSE;
  1585.     item = ItemAddress(BestellenMenus, code);
  1586.  
  1587.     /* Nichts ausgewählt, dann zurück                            */
  1588.     if( !item )
  1589.         return terminated;
  1590.  
  1591.     /* mal schaun, was ausgewählt wurde                            */
  1592.     switch ( (int)MENU_USERDATA(item) )
  1593.     {
  1594.         /* Menupunkt Öffnen Adressen/Einstellungen            */
  1595.         case MENU_FOO_OPA:
  1596.             /* Wenn die Asl.library geöffnet werden konnte    */
  1597.             if( AslBase )
  1598.             {
  1599.                 /* Verzeichnis ermitteln                            */
  1600.                 i = (unsigned)((STRPTR)PathPart(Einst_File) - (STRPTR)Einst_File);
  1601.                 strncpy(Verzeichnis,Einst_File,i);
  1602.                 Verzeichnis[i] = 0;
  1603.                 /* Öffne einen einfachen Filerequester            */
  1604.                 if (fr = ( struct FileRequester *)AllocAslRequestTags(ASL_FileRequest,
  1605.                                                                                         ASL_Dir, Verzeichnis,
  1606.                                                                                         ASL_File, FilePart(Einst_File),
  1607.                                                                                         TAG_DONE))
  1608.                 {
  1609.                     if(AslRequest(fr,NULL))
  1610.                     {
  1611.                         /* Der neue Filerequester setzt sich    */
  1612.                         /* aus Drawer und File zusammen.            */
  1613.                         strcpy(Einst_File, fr->fr_Drawer);
  1614.                         strcat(Einst_File, fr->fr_File);
  1615.                         /* Gut, schreibe die Bestellung            */
  1616.                         EinstLesen();
  1617.                         /* Und auf den Bildschirm damit            */
  1618.                         Winfuell();
  1619.                     }
  1620.                     FreeAslRequest(fr);
  1621.                 }
  1622.             }
  1623.             break;
  1624.  
  1625.         /* Menupunkt Öffnen Diskettenliste                        */
  1626.         case MENU_FOO_OPB:
  1627.             /* Wenn die Asl.library geöffnet werden konnte    */
  1628.             if( AslBase )
  1629.             {
  1630.                 /* Verzeichnis ermitteln                            */
  1631.                 i = (unsigned)((STRPTR)PathPart(T_Remember) - (STRPTR)T_Remember);
  1632.                 strncpy(Verzeichnis,T_Remember,i);
  1633.                 Verzeichnis[i] = 0;
  1634.                 /* Öffne einen einfachen Filerequester            */
  1635.                 if (fr = ( struct FileRequester *)AllocAslRequestTags(ASL_FileRequest,
  1636.                                                                                         ASL_Dir, Verzeichnis,
  1637.                                                                                         ASL_File, FilePart(T_Remember),
  1638.                                                                                         TAG_DONE))
  1639.                 {
  1640.                     if(AslRequest(fr,NULL))
  1641.                     {
  1642.                         /* Der neue Filerequester setzt sich    */
  1643.                         /* aus Drawer und File zusammen.            */
  1644.                         strcpy(T_Remember, fr->fr_Drawer);
  1645.                         strcat(T_Remember, fr->fr_File);
  1646.                         /* Liste abhängen                                */
  1647.                         gt_AttachList( BestellenGadgets[ GD_Diskliste ], BestellenWnd, (struct List *) ~0 );
  1648.                         /* Alte Liste löschen                        */
  1649.                         while( ( n = (struct VDBnode *) RemHead( &vdblist ) ) )
  1650.                         {
  1651.                             FreeVec(n);
  1652.                         }
  1653.                         /* Gut, schreibe die Bestellung            */
  1654.                         DatenLesen();
  1655.                         /* Liste wieder dranhängen                    */
  1656.                         gt_AttachList( BestellenGadgets[ GD_Diskliste ], BestellenWnd, &vdblist );
  1657.                         /* Bearbeitungsgadget löschen                */
  1658.                         gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, "");
  1659.                         /* Gadgets ausblenden                        */
  1660.                         checkonoff();
  1661.                     }
  1662.                     FreeAslRequest(fr);
  1663.                 }
  1664.             }
  1665.             break;
  1666.  
  1667.         /* Menupunkt Speichern Adressen/Einstellungen        */
  1668.         case MENU_FOO_SPA:
  1669.             EinstSchreiben();
  1670.             break;
  1671.  
  1672.         /* Menupunkt Speichern Diskettenliste                    */
  1673.         case MENU_FOO_SPB:
  1674.             DatenSchreiben(&vdblist);
  1675.             break;
  1676.  
  1677.         /* Menupunkt Speichern als ... Adressen/Einstell.    */
  1678.         case MENU_FOO_SAA:
  1679.             /* Wenn die Asl.library geöffnet werden konnte    */
  1680.             if( AslBase )
  1681.             {
  1682.                 /* Verzeichnis ermitteln                            */
  1683.                 i = (unsigned)((STRPTR)PathPart(Einst_File) - (STRPTR)Einst_File);
  1684.                 strncpy(Verzeichnis,Einst_File,i);
  1685.                 Verzeichnis[i] = 0;
  1686.                 /* Öffne einen einfachen Filerequester            */
  1687.                 if (fr = ( struct FileRequester *)AllocAslRequestTags(ASL_FileRequest,
  1688.                                                                                         ASL_Dir, Verzeichnis,
  1689.                                                                                         ASL_File, FilePart(Einst_File),
  1690.                                                                                         TAG_DONE))
  1691.                 {
  1692.                     if(AslRequest(fr,NULL))
  1693.                     {
  1694.                         /* Der neue Filerequester setzt sich    */
  1695.                         /* aus Drawer und File zusammen.            */
  1696.                         strcpy(Einst_File, fr->fr_Drawer);
  1697.                         strcat(Einst_File, fr->fr_File);
  1698.                         EinstSchreiben();
  1699.                     }
  1700.                     FreeAslRequest(fr);
  1701.                 }
  1702.             }
  1703.             break;
  1704.  
  1705.         /* Menupunkt Speichern als ... Diskettenliste        */
  1706.         case MENU_FOO_SAB:
  1707.             /* Wenn die Asl.library geöffnet werden konnte    */
  1708.             if( AslBase )
  1709.             {
  1710.                 /* Verzeichnis ermitteln                            */
  1711.                 i = (unsigned)((STRPTR)PathPart(T_Remember) - (STRPTR)T_Remember);
  1712.                 strncpy(Verzeichnis,T_Remember,i);
  1713.                 Verzeichnis[i] = 0;
  1714.                 /* Öffne einen einfachen Filerequester            */
  1715.                 if (fr = ( struct FileRequester *)AllocAslRequestTags(ASL_FileRequest,
  1716.                                                                                         ASL_Dir, Verzeichnis,
  1717.                                                                                         ASL_File, FilePart(T_Remember),
  1718.                                                                                         TAG_DONE))
  1719.                 {
  1720.                     if(AslRequest(fr,NULL))
  1721.                     {
  1722.                         /* Der neue Filerequester setzt sich    */
  1723.                         /* aus Drawer und File zusammen.            */
  1724.                         strcpy(T_Remember, fr->fr_Drawer);
  1725.                         strcat(T_Remember, fr->fr_File);
  1726.                         DatenSchreiben( &vdblist );
  1727.                     }
  1728.                     FreeAslRequest(fr);
  1729.                 }
  1730.             }
  1731.             break;
  1732.  
  1733.         /* Menupunkt Drucken                                            */
  1734.         case MENU_FOO_DRU:
  1735.             /* Unterprogramm zum Drucken starten                */
  1736.             Drucken(&vdblist);
  1737.             break;
  1738.  
  1739.         /* Menupunkt Information                                    */
  1740.         case MENU_FOO_INF:
  1741.             /* Starten wir nen kleinen Inforequester            */
  1742.             es.es_StructSize    = sizeof(struct EasyStruct);
  1743.             es.es_Flags            = 0;
  1744.             es.es_Title            = AppStrings[MSG_InfoReqTitel];
  1745.             es.es_TextFormat    = AppStrings[MSG_InfoReqText];
  1746.             es.es_GadgetFormat= AppStrings[MSG_InfoReqWahl];
  1747.  
  1748.             EasyRequest(BestellenWnd, &es, NULL);
  1749.             break;
  1750.  
  1751.         /* Menupunkt Verbergen                                        */
  1752.         case MENU_FOO_HID:
  1753.             /* Fenster schließen                                        */
  1754.             CloseBestellenWindow();
  1755.             break;
  1756.  
  1757.         /* Menupunkt Programm beenden                                */
  1758.         case MENU_FOO_END:
  1759.             /* gut, Rückgabewert auf Ende setzen                */
  1760.             terminated = TRUE;
  1761.             break;
  1762.  
  1763.         /* Sollte nicht vorkommen                                    */
  1764.         default:
  1765.             break;
  1766.     }
  1767.     /* Rückgabewert, ob der User weitermachen will            */
  1768.     return(terminated);
  1769. }
  1770.  
  1771. /* Eine handelsübliche Taste wurde gedrückt                    */
  1772. BOOL Abfrage_Vanillakey( struct Gadget *gad, UWORD code)
  1773. {
  1774.     BOOL terminated = FALSE;
  1775.  
  1776.     /* Wollen wir doch mal sehen, welche da benutzt wurde    */
  1777.     if ((code == AppStrings[MSG_GadgetKey1a][0]) ||
  1778.         (code == AppStrings[MSG_GadgetKey1b][0]))
  1779.         {
  1780.             /* ist ein Eintrag in der liste ausgewählt?        */
  1781.             if( currentvdb )
  1782.                 /* ja, dann aktiviere das Feld unter der Liste*/
  1783.                 ActivateGadget( BestellenGadgets[GD_DiskAender], BestellenWnd, NULL );
  1784.             else if(gt_GetListNumEntries( &vdblist ) > 0)
  1785.             {
  1786.                 /* nein, dann selektiere den ersten Eintrag    */
  1787.                 currentvdb = (struct VDBnode *) gt_GetListEntry(&vdblist, 0);
  1788.                 gt_SetLV(BestellenGadgets[GD_Diskliste], BestellenWnd, gt_GetListEntryNum(&vdblist, (struct Node *) currentvdb));
  1789.                 /* aktiviere alle Gadgets                            */
  1790.                 checkonoff();
  1791.                 /* und setz den Disknamen ins String-Gadget    */
  1792.                 gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, currentvdb->d.Name );
  1793.             }
  1794.         }
  1795.  
  1796.         /* Neuer Listeneintrag                                        */
  1797.     else if ((code == AppStrings[MSG_GadgetKey2a][0]) ||
  1798.         (code == AppStrings[MSG_GadgetKey2b][0]))
  1799.         {
  1800.             /* dafür haben wir doch ein Unterprogramm            */
  1801.             newvdb();
  1802.         }
  1803.  
  1804.         /* Jemand will nen Diskeintrag löschen                    */
  1805.     else if ((code == AppStrings[MSG_GadgetKey3a][0]) ||
  1806.         (code == AppStrings[MSG_GadgetKey3b][0]))
  1807.         {
  1808.             /* Nur wenn ein Eintrag aktiviert ist löschen    */
  1809.             if( currentvdb )
  1810.                 EintragLoeschen();
  1811.         }
  1812.  
  1813.         /* Drucken                                                        */
  1814.     else if ((code == AppStrings[MSG_GadgetKey5a][0]) ||
  1815.         (code == AppStrings[MSG_GadgetKey5b][0]))
  1816.         {
  1817.             /* Druckroutine starten                                    */
  1818.             Drucken(&vdblist);
  1819.         }
  1820.  
  1821.         /* Abbrechen                                                    */
  1822.     else if ((code == AppStrings[MSG_GadgetKey6a][0]) ||
  1823.         (code == AppStrings[MSG_GadgetKey6b][0]))
  1824.         {
  1825.             /* Wenn er nimmer will, halten wir ihn nicht auf*/
  1826.             terminated = TRUE;
  1827.         }
  1828.  
  1829.         /* Absendername                                                */
  1830.     else if ((code == AppStrings[MSG_GadgetKey7a][0]) ||
  1831.         (code == AppStrings[MSG_GadgetKey7b][0]))
  1832.         {
  1833.             ActivateGadget( BestellenGadgets[GD_AName], BestellenWnd, NULL );
  1834.         }
  1835.  
  1836.         /* Absenderstraße                                                */
  1837.     else if ((code == AppStrings[MSG_GadgetKey8a][0]) ||
  1838.         (code == AppStrings[MSG_GadgetKey8b][0]))
  1839.         {
  1840.             ActivateGadget( BestellenGadgets[GD_AStrasse], BestellenWnd, NULL );
  1841.         }
  1842.  
  1843.         /* Absenderort                                                    */
  1844.     else if ((code == AppStrings[MSG_GadgetKey9a][0]) ||
  1845.         (code == AppStrings[MSG_GadgetKey9b][0]))
  1846.         {
  1847.             ActivateGadget( BestellenGadgets[GD_AOrt], BestellenWnd, NULL );
  1848.         }
  1849.  
  1850.         /* Kundennummer                                                */
  1851.     else if ((code == AppStrings[MSG_GadgetKey10a][0]) ||
  1852.         (code == AppStrings[MSG_GadgetKey10b][0]))
  1853.         {
  1854.             ActivateGadget( BestellenGadgets[GD_KundNr], BestellenWnd, NULL );
  1855.         }
  1856.  
  1857.         /* Empfängername                                                */
  1858.     else if ((code == AppStrings[MSG_GadgetKey11a][0]) ||
  1859.         (code == AppStrings[MSG_GadgetKey11b][0]))
  1860.         {
  1861.             ActivateGadget( BestellenGadgets[GD_EName], BestellenWnd, NULL );
  1862.         }
  1863.  
  1864.         /* Empfängerstraße                                            */
  1865.     else if ((code == AppStrings[MSG_GadgetKey12a][0]) ||
  1866.         (code == AppStrings[MSG_GadgetKey12b][0]))
  1867.         {
  1868.             ActivateGadget( BestellenGadgets[GD_EStrasse], BestellenWnd, NULL );
  1869.         }
  1870.  
  1871.         /* Empfänger Postleitzahl/Ort                                */
  1872.     else if ((code == AppStrings[MSG_GadgetKey13a][0]) ||
  1873.         (code == AppStrings[MSG_GadgetKey13b][0]))
  1874.         {
  1875.             ActivateGadget( BestellenGadgets[GD_EOrt], BestellenWnd, NULL );
  1876.         }
  1877.  
  1878.         /* Leerzeilen vorm Ausdruck                                */
  1879.     else if ((code == AppStrings[MSG_GadgetKey15a][0]) ||
  1880.         (code == AppStrings[MSG_GadgetKey15b][0]))
  1881.         {
  1882.             ActivateGadget( BestellenGadgets[GD_Abstand], BestellenWnd, NULL );
  1883.         }
  1884.  
  1885.         /* Zahlungsart Nachnahme                                    */
  1886.     else if ((code == AppStrings[MSG_VerKey1a][0]) ||
  1887.         (code == AppStrings[MSG_VerKey1b][0]))
  1888.         {
  1889.             P1.Versart = 0;
  1890.             GT_SetGadgetAttrs( BestellenGadgets[ GD_Zahlart ], BestellenWnd, NULL, 
  1891.                                         GTMX_Active, P1.Versart,
  1892.                                         TAG_DONE);
  1893.         }
  1894.  
  1895.         /* Zahlungsart Vorkasse                                        */
  1896.     else if ((code == AppStrings[MSG_VerKey2a][0]) ||
  1897.         (code == AppStrings[MSG_VerKey2b][0]))
  1898.         {
  1899.             P1.Versart = 1;
  1900.             GT_SetGadgetAttrs( BestellenGadgets[ GD_Zahlart ], BestellenWnd, NULL, 
  1901.                                         GTMX_Active, P1.Versart,
  1902.                                         TAG_DONE);
  1903.         }
  1904.  
  1905.         /* Zahlungsart Rechnung                                        */
  1906.     else if ((code == AppStrings[MSG_VerKey3a][0]) ||
  1907.         (code == AppStrings[MSG_VerKey3b][0]))
  1908.         {
  1909.             P1.Versart = 2;
  1910.             GT_SetGadgetAttrs( BestellenGadgets[ GD_Zahlart ], BestellenWnd, NULL, 
  1911.                                         GTMX_Active, P1.Versart,
  1912.                                         TAG_DONE);
  1913.         }
  1914.  
  1915.         /* andere Eingaben interressieren uns nicht            */
  1916.     else
  1917.         {
  1918.         }
  1919.     /* und der der obligatorische Rückgabewert                */
  1920.     return(terminated);
  1921. }
  1922.  
  1923. /* eine der Tasten die nix aufm Bildschirm hinterlassen    */
  1924. void Abfrage_Rawkey( struct Gadget *gad, UWORD code, struct Gadget *gd)
  1925. {
  1926.     int i;
  1927.  
  1928.     /* Ein paar Sachen für einen AmigaGuide aufruf            */
  1929.     struct NewAmigaGuide sync = {NULL};
  1930.     static UBYTE *AG_ID[] = {
  1931.         "GD_Diskliste",
  1932.         "GD_NeueDisk",
  1933.         "GD_DiskLoeschen",
  1934.         "GD_Zahlart",
  1935.         "GD_Drucken",
  1936.         "GD_Abbrechen",
  1937.         "GD_AName",
  1938.         "GD_AStrasse",
  1939.         "GD_AOrt",
  1940.         "GD_KundNr",
  1941.         "GD_EName",
  1942.         "GD_EStrasse",
  1943.         "GD_EOrt",
  1944.         "GD_DiskAender",
  1945.         "GD_Abstand",
  1946.     };
  1947.  
  1948.     AMIGAGUIDECONTEXT MyHandle;
  1949.  
  1950.     switch ( code )
  1951.     {
  1952.         /* Cursor hoch (Listview hoch)                            */
  1953.         case 76:
  1954.             /* sollte überhaupt ein Eintrag aktiv sein        */
  1955.             if( currentvdb )
  1956.             {
  1957.                 /* kucken wir, welche Nummer der hat            */
  1958.                 i = gt_GetListEntryNum( &vdblist, (struct Node *) currentvdb );
  1959.                 /* senken die Nummer um 1 und                        */
  1960.                 i--;
  1961.                 /* sollten wir noch nicht ganz oben sein        */
  1962.                 if(i >= 0)
  1963.                 {
  1964.                     /* haben wir einen neuen aktuellen Eintr.    */
  1965.                     currentvdb = (struct VDBnode *) gt_GetListEntry(&vdblist, i);    
  1966.                     gt_SetLV(BestellenGadgets[GD_Diskliste], BestellenWnd, gt_GetListEntryNum(&vdblist, (struct Node *) currentvdb));
  1967.                     /* ab damit ins Feld unter der Liste        */
  1968.                     gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, currentvdb->d.Name );
  1969.                 }
  1970.             }
  1971.             else if(gt_GetListNumEntries( &vdblist ) > 0)
  1972.             {
  1973.                 /* nein, dann selektiere den ersten Eintrag    */
  1974.                 currentvdb = (struct VDBnode *) gt_GetListEntry(&vdblist, 0);
  1975.                 gt_SetLV(BestellenGadgets[GD_Diskliste], BestellenWnd, gt_GetListEntryNum(&vdblist, (struct Node *) currentvdb));
  1976.                 /* aktiviere alle Gadgets                            */
  1977.                 checkonoff();
  1978.                 /* und setz den Disknamen ins String-Gadget    */
  1979.                 gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, currentvdb->d.Name );
  1980.             }
  1981.             break;
  1982.  
  1983.         /* Cursor hoch (Listview hoch)                            */
  1984.         case 77:
  1985.             /* sollte überhaupt ein Eintrag aktiv sein        */
  1986.             if( currentvdb )
  1987.             {
  1988.                 /* kucken wir, welche Nummer der hat            */
  1989.                 i = gt_GetListEntryNum( &vdblist, (struct Node *) currentvdb );
  1990.                 /* erhöhen die Nummer um 1 und                    */
  1991.                 i++;
  1992.                 /* sollten wir noch nicht ganz unten sein,    */
  1993.                 if(i < gt_GetListNumEntries( &vdblist ))
  1994.                 {
  1995.                     /* haben wir einen neuen aktuellen Eintr.    */
  1996.                     currentvdb = (struct VDBnode *) gt_GetListEntry(&vdblist, i);    
  1997.                     /* ab damit ins Feld unter der Liste        */
  1998.                     gt_SetLV(BestellenGadgets[GD_Diskliste], BestellenWnd, gt_GetListEntryNum(&vdblist, (struct Node *) currentvdb));
  1999.                     gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, currentvdb->d.Name );
  2000.                 }
  2001.             }
  2002.             else if(gt_GetListNumEntries( &vdblist ) > 0)
  2003.             {
  2004.                 /* nein, dann selektiere den ersten Eintrag    */
  2005.                 currentvdb = (struct VDBnode *) gt_GetListEntry(&vdblist, gt_GetListNumEntries( &vdblist )-1 );
  2006.                 gt_SetLV(BestellenGadgets[GD_Diskliste], BestellenWnd, gt_GetListEntryNum(&vdblist, (struct Node *) currentvdb));
  2007.                 /* aktiviere alle Gadgets                            */
  2008.                 checkonoff();
  2009.                 /* und setz den Disknamen ins String-Gadget    */
  2010.                 gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, currentvdb->d.Name );
  2011.             }
  2012.             break;
  2013.  
  2014.         /* Help-Taste gedrückt                                        */
  2015.         case 95:
  2016.             /* Ist die AmigaGuide Library geöffnet + OS 3.x    */
  2017.             if( AmigaGuideBase != NULL )
  2018.             {
  2019.                 /* Legen wir die Guide-Datei fest                */
  2020.                 sync.nag_Name    = "T_Bestellen.guide";
  2021.  
  2022.                 /* steht der Mauszeiger über keinem Gadget,    */
  2023.                 if(gd == NULL)
  2024.                     /* den defaultmäßigen Node setzen            */
  2025.                     sync.nag_Node    = "Window";
  2026.                 /* steht der Mauszeiger über einem Gadget,    */
  2027.                 else
  2028.                     /* wird dar passende Node gesetzt            */
  2029.                     sync.nag_Node = AG_ID[gd->GadgetID];
  2030.  
  2031.                 /* Gut, öffnen wir die Guide Datei                */
  2032.                 MyHandle = OpenAmigaGuide( &sync, NULL );
  2033.  
  2034.                 /* und schließen sie, wenn's öffnen klappte    */
  2035.                 if(MyHandle)
  2036.                     CloseAmigaGuide( MyHandle);
  2037.  
  2038.             }
  2039.             /* Ist die AmigaGuide Library nicht zu öffnen,    */
  2040.             else
  2041.             {
  2042.                 /* gibts ne Message, daß ohne AmigaGuide nix    */
  2043.                 /* los ist mit der OnlineHilfe                    */
  2044.                 es.es_StructSize    = sizeof(struct EasyStruct);
  2045.                 es.es_Flags            = 0;
  2046.                 es.es_Title            = AppStrings[MSG_ErrorReqTitel];
  2047.                 es.es_TextFormat    = AppStrings[MSG_ErrorReqText3];
  2048.                 es.es_GadgetFormat= AppStrings[MSG_ErrorReqWahl];
  2049.  
  2050.                 EasyRequest(BestellenWnd, &es, NULL);
  2051.             }
  2052.             break;
  2053.  
  2054.         /* Sonstige Tasten jucken mich derzeit nicht            */
  2055.         default:
  2056.             break;
  2057.     }
  2058. }
  2059.  
  2060. /* eine der Tasten die nix aufm Bildschirm hinterlassen    */
  2061. void Abfrage_Menuhelp( UWORD code)
  2062. {
  2063.     /* Ein paar Sachen für einen AmigaGuide aufruf            */
  2064.     struct NewAmigaGuide sync = {NULL};
  2065.  
  2066.     AMIGAGUIDECONTEXT MyHandle;
  2067.  
  2068.     /* Ist die AmigaGuide Library geöffnet + OS 3.x            */
  2069.     if( AmigaGuideBase != NULL )
  2070.     {
  2071.         /* Legen wir die Guide-Datei fest                        */
  2072.         sync.nag_Name    = "T_Bestellen.guide";
  2073.  
  2074.         /* steht der Mauszeiger über einem Menüpunkt?        */
  2075.         switch(code)
  2076.         {
  2077.             /* HELP beim Menü-Punkt Öffnen Adressen            */
  2078.             case 0:
  2079.                 sync.nag_Node    = "Menu_OPA";
  2080.                 break;
  2081.             /* HELP beim Menü-Punkt Öffnen Diskliste            */
  2082.             case 2048:
  2083.                 sync.nag_Node    = "Menu_OPB";
  2084.                 break;
  2085.             /* HELP beim Menü-Punkt Speichern Adressen        */
  2086.             case 32:
  2087.                 sync.nag_Node    = "Menu_SPA";
  2088.                 break;
  2089.             /* HELP beim Menü-Punkt Speichern Diskliste        */
  2090.             case 2080:
  2091.                 sync.nag_Node    = "Menu_SPB";
  2092.                 break;
  2093.             /* HELP beim Menü-Punkt Speichern als ... Adres.*/
  2094.             case 64:
  2095.                 sync.nag_Node    = "Menu_SAA";
  2096.                 break;
  2097.             /* HELP beim Menü-Punkt Speichern als... Diskl.    */
  2098.             case 2112:
  2099.                 sync.nag_Node    = "Menu_SAB";
  2100.                 break;
  2101.             /* HELP beim Menü-Punkt Drucken                        */
  2102.             case 63584:
  2103.                 sync.nag_Node    = "Menu_Dru";
  2104.                 break;
  2105.             /* HELP beim Menü-Punkt Über T_Bestellen ...        */
  2106.             case 63648:
  2107.                 sync.nag_Node    = "Menu_Inf";
  2108.                 break;
  2109.             /* HELP beim Menü-Punkt Speichern Adressen        */
  2110.             case 63712:
  2111.                 sync.nag_Node    = "Menu_HID";
  2112.                 break;
  2113.             /* HELP beim Menü-Punkt Beenden                        */
  2114.             case 63744:
  2115.                 sync.nag_Node    = "Menu_End";
  2116.                 break;
  2117.             /* HELP außerhalb des Menüs, oder über Trennb.    */
  2118.             default:
  2119.                 sync.nag_Node    = "Window";
  2120.                 break;
  2121.         }
  2122.  
  2123.         /* Gut, öffnen wir die Guide Datei                        */
  2124.         MyHandle = OpenAmigaGuide( &sync, NULL );
  2125.  
  2126.         /* und schließen sie, wenn's öffnen klappte            */
  2127.         if(MyHandle)
  2128.             CloseAmigaGuide( MyHandle);
  2129.  
  2130.     }
  2131.     /* Ist die AmigaGuide Library nicht zu öffnen,            */
  2132.     else
  2133.     {
  2134.         /* gibts ne Message, daß ohne AmigaGuide nix            */
  2135.         /* los ist mit der OnlineHilfe                            */
  2136.         es.es_StructSize    = sizeof(struct EasyStruct);
  2137.         es.es_Flags            = 0;
  2138.         es.es_Title            = AppStrings[MSG_ErrorReqTitel];
  2139.         es.es_TextFormat    = AppStrings[MSG_ErrorReqText3];
  2140.         es.es_GadgetFormat= AppStrings[MSG_ErrorReqWahl];
  2141.  
  2142.         EasyRequest(BestellenWnd, &es, NULL);
  2143.     }
  2144. }
  2145.  
  2146. /* Verarbeiten der Commodity-Botschaften                        */
  2147. BOOL Cx_Message( CxMsg *msg )
  2148. {
  2149.     ULONG msgid, msgtype;
  2150.     BOOL terminated = FALSE;
  2151.     /* Message ID ermitteln                                            */
  2152.     msgid = CxMsgID(msg);
  2153.     /* Ebenso den Typ                                                    */
  2154.     msgtype = CxMsgType(msg);
  2155.     /* Eine Botschaft sollte auch beantwortet werden        */
  2156.     ReplyMsg((struct Message *)msg);
  2157.     /* Messagetyp auswerten                                            */
  2158.     switch(msgtype)
  2159.     {
  2160.         /* Benutzerdefinierte Ereignisse                            */
  2161.         case CXM_IEVENT:
  2162.             switch( msgid )
  2163.             {
  2164.                 /* HotKey wurde betätigt                            */
  2165.                 case EVT_HOTKEY:
  2166.                     if( CX_Popup )
  2167.                         WindowToFront( BestellenWnd );
  2168.                     else
  2169.                     {
  2170.                         OpenBestellenWindow();
  2171.                         Winfuell();
  2172.                         if( currentvdb )
  2173.                         {
  2174.                             gt_SetLV(BestellenGadgets[GD_Diskliste], BestellenWnd, ListPos);
  2175.                             gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, currentvdb->d.Name );
  2176.                         }
  2177.                     }
  2178.                     break;
  2179.                 /* eigentlich wird sonst niemand erwartet        */
  2180.                 default:
  2181.                     break;
  2182.             }
  2183.             break;
  2184.         /* Kommando, bekannt aus Exchange                        */
  2185.         case CXM_COMMAND:
  2186.             switch( msgid )
  2187.             {
  2188.                 /* Commodity schlafen schicken                    */
  2189.                 case CXCMD_DISABLE:
  2190.                     ActivateCxObj(broker, 0L);
  2191.                     break;
  2192.                 /* und wieder aufwecken                                */
  2193.                 case CXCMD_ENABLE:
  2194.                     ActivateCxObj(broker, 1L);
  2195.                     break;
  2196.                 /* Keine Lust mehr? Beendet das Programm        */
  2197.                 case CXCMD_KILL:
  2198.                     terminated = TRUE;
  2199.                     break;
  2200.                 /* Programm wurde nochmal gestartet                */
  2201.                 /* Fenster öffnen                                        */
  2202.                 case CXCMD_UNIQUE:
  2203.                 case CXCMD_APPEAR:
  2204.                     if( CX_Popup )
  2205.                         WindowToFront( BestellenWnd );
  2206.                     else
  2207.                     {
  2208.                         OpenBestellenWindow();
  2209.                         Winfuell();
  2210.                         if( currentvdb )
  2211.                         {
  2212.                             gt_SetLV(BestellenGadgets[GD_Diskliste], BestellenWnd, ListPos);
  2213.                             gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, currentvdb->d.Name );
  2214.                         }
  2215.                     }
  2216.                     break;
  2217.                 /* Fenster verbergen                                    */
  2218.                 case CXCMD_DISAPPEAR:
  2219.                     if( CX_Popup )
  2220.                         CloseBestellenWindow();
  2221.                     break;
  2222.                 default:
  2223.                     break;
  2224.             }
  2225.             break;
  2226.         default:
  2227.             break;
  2228.     }
  2229.     return terminated;
  2230. }
  2231.  
  2232.  
  2233. /* Lokalisierte Texte einlesen (wenn vorhanden)                */
  2234. void LocaleLesen()
  2235. {
  2236.     if (LocaleBase) {
  2237.         struct    Catalog    *catalog = OpenCatalog (NULL,"T_Bestellen.catalog",OC_BuiltInLanguage,MSG_Language,TAG_DONE) ;
  2238.         if (catalog) {
  2239.             UBYTE    n ;
  2240.             for (n=0 ; n<=MSG_Max ; n++)
  2241.                 AppStrings[n] = GetCatalogStr (catalog,n,AppStrings[n]) ;
  2242.             CloseCatalog (catalog) ;
  2243.         }
  2244.     }
  2245.     /* Hotkey-Vermerk an den Fenstertitel anhängen            */
  2246.     strcpy(WinTitel, AppStrings[MSG_WindowName]);
  2247.     strcat(WinTitel, CX_Popkey);
  2248.     strcat(WinTitel, ">");
  2249.  
  2250.     /* MenuTexte übernehmen                                            */
  2251.     BestellenNewMenu[0].nm_Label = AppStrings[MSG_MenuText1];
  2252.     BestellenNewMenu[1].nm_Label = AppStrings[MSG_MenuText2];
  2253.     BestellenNewMenu[2].nm_Label = AppStrings[MSG_MenuText2a];
  2254.     BestellenNewMenu[3].nm_Label = AppStrings[MSG_MenuText2b];
  2255.     BestellenNewMenu[4].nm_Label = AppStrings[MSG_MenuText3];
  2256.     BestellenNewMenu[5].nm_Label = AppStrings[MSG_MenuText2a];
  2257.     BestellenNewMenu[6].nm_Label = AppStrings[MSG_MenuText2b];
  2258.     BestellenNewMenu[7].nm_Label = AppStrings[MSG_MenuText4];
  2259.     BestellenNewMenu[8].nm_Label = AppStrings[MSG_MenuText2a];
  2260.     BestellenNewMenu[9].nm_Label = AppStrings[MSG_MenuText2b];
  2261.     BestellenNewMenu[10].nm_Label = AppStrings[MSG_MenuText5];
  2262.     BestellenNewMenu[12].nm_Label = AppStrings[MSG_MenuText6];
  2263.     BestellenNewMenu[14].nm_Label = AppStrings[MSG_MenuText7];
  2264.     BestellenNewMenu[15].nm_Label = AppStrings[MSG_MenuText8];
  2265.  
  2266.     /* Menu-ShortCuts übernehmen                                    */
  2267.     BestellenNewMenu[2].nm_CommKey = AppStrings[MSG_MenuKey2];
  2268.     BestellenNewMenu[3].nm_CommKey = AppStrings[MSG_MenuKey2b];
  2269.     BestellenNewMenu[5].nm_CommKey = AppStrings[MSG_MenuKey3];
  2270.     BestellenNewMenu[6].nm_CommKey = AppStrings[MSG_MenuKey3b];
  2271.     BestellenNewMenu[8].nm_CommKey = AppStrings[MSG_MenuKey4];
  2272.     BestellenNewMenu[9].nm_CommKey = AppStrings[MSG_MenuKey4b];
  2273.     BestellenNewMenu[10].nm_CommKey = AppStrings[MSG_MenuKey5];
  2274.     BestellenNewMenu[12].nm_CommKey = AppStrings[MSG_MenuKey6];
  2275.     BestellenNewMenu[14].nm_CommKey = AppStrings[MSG_MenuKey7];
  2276.     BestellenNewMenu[15].nm_CommKey = AppStrings[MSG_MenuKey8];
  2277.  
  2278.     /* Gadget-Texte übernehmen                                        */
  2279.     BestellenNGad[0].ng_GadgetText = AppStrings[MSG_GadgetText1];
  2280.     BestellenNGad[1].ng_GadgetText = AppStrings[MSG_GadgetText2];
  2281.     BestellenNGad[2].ng_GadgetText = AppStrings[MSG_GadgetText3];
  2282.     BestellenNGad[4].ng_GadgetText = AppStrings[MSG_GadgetText5];
  2283.     BestellenNGad[5].ng_GadgetText = AppStrings[MSG_GadgetText6];
  2284.     BestellenNGad[6].ng_GadgetText = AppStrings[MSG_GadgetText7];
  2285.     BestellenNGad[7].ng_GadgetText = AppStrings[MSG_GadgetText8];
  2286.     BestellenNGad[8].ng_GadgetText = AppStrings[MSG_GadgetText9];
  2287.     BestellenNGad[9].ng_GadgetText = AppStrings[MSG_GadgetText10];
  2288.     BestellenNGad[10].ng_GadgetText = AppStrings[MSG_GadgetText11];
  2289.     BestellenNGad[11].ng_GadgetText = AppStrings[MSG_GadgetText12];
  2290.     BestellenNGad[12].ng_GadgetText = AppStrings[MSG_GadgetText13];
  2291.     BestellenNGad[14].ng_GadgetText = AppStrings[MSG_GadgetText15];
  2292.  
  2293.     /* IText (Infotexte auf dem Screen)                            */
  2294.     BestellenIText[0].IText = AppStrings[MSG_IText1];
  2295.     BestellenIText[1].IText = AppStrings[MSG_IText2];
  2296.  
  2297.     /* MX-Gadget (Versandarten-Gadget)                            */
  2298.     Gadget300Labels[0] = AppStrings[MSG_Versandart1];
  2299.     Gadget300Labels[1] = AppStrings[MSG_Versandart2];
  2300.     Gadget300Labels[2] = AppStrings[MSG_Versandart3];
  2301. }
  2302.  
  2303. /* IconToolTypes einlesen                                            */
  2304. void ToolTypesLesen(char *name)
  2305. {
  2306.     struct DiskObject        *diskobj;
  2307.     char *s;
  2308.  
  2309.     /* Icon.library geöffnet?                                        */
  2310.     if ( IconBase )
  2311.     {
  2312.         diskobj = GetDiskObject( name );
  2313.         if (diskobj)
  2314.         {
  2315.             if (s = FindToolType((STRPTR *)diskobj->do_ToolTypes,"POSX"))
  2316.                 WinX = atoi(s);
  2317.             if (s = FindToolType((STRPTR *)diskobj->do_ToolTypes,"POSY"))
  2318.                 WinY = atoi(s);
  2319.             if (s = FindToolType((STRPTR *)diskobj->do_ToolTypes,"DISKFILE"))
  2320.                 strcpy(T_Remember, s);
  2321.             if (s = FindToolType((STRPTR *)diskobj->do_ToolTypes,"ADDRFILE"))
  2322.                 strcpy(Einst_File, s);
  2323.             if (s = FindToolType((STRPTR *)diskobj->do_ToolTypes,"CX_PRIORITY"))
  2324.                 CX_Priority = atoi(s);
  2325.             if (s = FindToolType((STRPTR *)diskobj->do_ToolTypes,"CX_POPUP"))
  2326.                 if(MatchToolValue(s,"NO"))
  2327.                     CX_Popup = FALSE;
  2328.             if (s = FindToolType((STRPTR *)diskobj->do_ToolTypes,"CX_POPKEY"))
  2329.                 strcpy(CX_Popkey, s);
  2330.             FreeDiskObject (diskobj);
  2331.         }        
  2332.     }
  2333. }
  2334.  
  2335. /* Einrichten des Programms als Commodity                        */
  2336. void StartCom()
  2337. {
  2338.     translate = NULL;
  2339.     if ( CxBase )
  2340.     {
  2341.         /* NewBroker Structur füllen:                                */
  2342.         /* Version der NewBroker strukt. (immer NB_Version)*/
  2343.         newbroker.nb_Version = NB_VERSION;
  2344.         /* Programmname, erscheint dann in der Exchange-L.    */
  2345.         newbroker.nb_Name = (char *)AppStrings[MSG_MXName];
  2346.         /* Programmbezeich., erste Zeile Exchange B.            */
  2347.         newbroker.nb_Title = (char *)AppStrings[MSG_MXInfoName];
  2348.         /* Programmbeschreibung, zweite Zeile Exchange B.    */
  2349.         newbroker.nb_Descr = (char *)AppStrings[MSG_MXInfoText];
  2350.         /* Doppelten Start des PGMs verhindern und            */
  2351.         /* Nachricht an das Laufende Programm, beim Versuch*/
  2352.         newbroker.nb_Unique = NBU_UNIQUE | NBU_NOTIFY;
  2353.         /* Fenster ist vorhanden!                                    */
  2354.         newbroker.nb_Flags = COF_SHOW_HIDE;
  2355.         /* Priorität des Commodities (per ToolType wählb.)    */
  2356.         newbroker.nb_Pri = CX_Priority;
  2357.         /* MsgPort, der muß aber erst eingerichtet werden    */
  2358.         newbroker.nb_Port = CreateMsgPort();
  2359.         /* Der Rest ist für künftige Funktionen reserviert    */
  2360.         newbroker.nb_ReservedChannel = NULL;
  2361.  
  2362.         /* Broker an Commodity-Lib zur Anmeldung übergeben    */
  2363.         if( broker = CxBroker(&newbroker,NULL) )
  2364.         {
  2365.             /* Hotkey zu Filterobjekt verarbeiten                */
  2366.             if (filter = CxFilter(CX_Popkey))
  2367.             {
  2368.                 /* HotKey Filter an broker anhängen                */
  2369.                 AttachCxObj(broker, filter);
  2370.                 if (sender = CxSender(newbroker.nb_Port, EVT_HOTKEY))
  2371.                 {
  2372.                     AttachCxObj(filter,sender);
  2373.                     if (translate = CxTranslate(NULL))
  2374.                     {
  2375.                         AttachCxObj(filter,translate);
  2376.                         if(!CxObjError(filter))
  2377.                         {
  2378.                             /* Broker aktivieren                        */
  2379.                             ActivateCxObj(broker, 1L);
  2380.                             /* Signal-Bit merken, für Abfrage    */
  2381.                             cxsigflag = 1L << newbroker.nb_Port->mp_SigBit;
  2382.                         }
  2383.                     }
  2384.                 }
  2385.             }
  2386.         }
  2387.     }
  2388. }
  2389.  
  2390. /* Einrichten der Notify-Struktur                                */
  2391. void NotifyStarten()
  2392. {
  2393.     if(nr = (struct NotifyRequest*)AllocVec
  2394.     (sizeof(struct NotifyRequest),MEMF_PUBLIC|MEMF_CLEAR))
  2395.     {
  2396.         if(nmp = CreateMsgPort())
  2397.         {
  2398.             nr->nr_Name        = T_Remember;
  2399.             nr->nr_Flags    = NRF_SEND_MESSAGE | NRF_WAIT_REPLY | NRF_NOTIFY_INITIAL;
  2400.             nr->nr_stuff.nr_Msg.nr_Port = nmp;
  2401.  
  2402.             StartNotify(nr);
  2403.         }
  2404.     }
  2405. }
  2406.  
  2407. /* Hauptprogramm                                                        */
  2408. int main( int argc, char *argv[] )
  2409. {
  2410.     /* Hatt das öffnen der Libraries hingehauen?                */
  2411.     if( OpenAll() == TRUE )
  2412.     {
  2413.         struct    VDBnode    *n;
  2414.         struct    IntuiMessage    *imsg;
  2415.         struct    Gadget    *gad;
  2416.         struct    Gadget    *gd = NULL;
  2417.         ULONG        imsgClass;
  2418.         UWORD        imsgCode;
  2419.         BOOL        Done    = FALSE;
  2420.         CxMsg        *msg;
  2421.  
  2422.         /* Einlesen der ToolTypes (für Benutzereinstell.)    */
  2423.         /* In argv[0] steht übrigens der Programmname        */
  2424.         ToolTypesLesen(argv[0]);
  2425.  
  2426.         /* Einlesen der Locale-Daten (für andere Sprachen)    */
  2427.         LocaleLesen();
  2428.  
  2429.         /* Als Commodity einrichten                                */
  2430.         StartCom();
  2431.         if (!translate)
  2432.             exit(0);
  2433.  
  2434.         /* Einstellungen lesen                                        */
  2435.         EinstLesen();
  2436.  
  2437.         /* Daten lesen                                                    */
  2438.         DatenLesen();
  2439.  
  2440.         /* Notify einrichten und starten                            */
  2441.         NotifyStarten();
  2442.  
  2443.         /* Bildschirm vorbereiten                                    */
  2444.         SetupScreen();
  2445.         /* Fenster öffnen, wenn per ToolTypes so gewählt    */
  2446.         if ( CX_Popup )
  2447.         {
  2448.             OpenBestellenWindow();
  2449.             /* Window mit Voreinstellungen füllen                */
  2450.             Winfuell();
  2451.         }
  2452.  
  2453.         /* Hauptschleife                                                */
  2454.         while( !Done )
  2455.         {
  2456.             /* Auf IntuiMassage warten                                */
  2457.             Wait( cxsigflag | wndsigflag | 1L << nmp->mp_SigBit );
  2458.  
  2459.             /* und Auswerten (Commodity)                            */
  2460.             if (cxsigflag)
  2461.             {
  2462.                 while(msg = (CxMsg *)GetMsg(newbroker.nb_Port))
  2463.                 {
  2464.                     Done = Cx_Message(msg);
  2465.                 }
  2466.             }
  2467.  
  2468.             /* Auswertung von Disk-Dateiveränderungen:        */
  2469.             if( 1L << nmp->mp_SigBit )
  2470.             {
  2471.                 while( nm = (struct NotifyMessage*)GetMsg(nmp))
  2472.                 {
  2473.                     switch(nm->nm_Class)
  2474.                     {
  2475.                         case NOTIFY_CLASS:
  2476.                             /* Liste abhängen                            */
  2477.                             if( CX_Popup )
  2478.                                 gt_AttachList( BestellenGadgets[ GD_Diskliste ], BestellenWnd, (struct List *) ~0 );
  2479.                             /* Alte Liste löschen                    */
  2480.                             while( ( n = (struct VDBnode *) RemHead( &vdblist ) ) )
  2481.                             {
  2482.                                 FreeVec(n);
  2483.                             }
  2484.                             /* Gut, schreibe die Bestellung        */
  2485.                             DatenLesen();
  2486.                             /* Liste wieder dranhängen                */
  2487.                             if( CX_Popup )
  2488.                             {
  2489.                                 gt_AttachList( BestellenGadgets[ GD_Diskliste ], BestellenWnd, &vdblist );
  2490.                                 /* Bearbeitungsgadget löschen        */
  2491.                                 gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, "");
  2492.                                 /* Gadgets ausblenden                */
  2493.                                 checkonoff();
  2494.                             }
  2495.                             break;
  2496.                         default:
  2497.                             break;
  2498.                     }
  2499.                     ReplyMsg(&nm->nm_ExecMessage);
  2500.                 }
  2501.             }
  2502.  
  2503.             /* Nachricht vom Fenster                                */ 
  2504.             while((CX_Popup) && (imsg = GT_GetIMsg(BestellenWnd->UserPort)))
  2505.             {
  2506.                 imsgClass        = imsg->Class;
  2507.                 imsgCode            = imsg->Code;
  2508.                 gad = (struct Gadget *)imsg->IAddress;
  2509.  
  2510.                 /* Jede empfangen Nachricht bestätigen            */
  2511.                 GT_ReplyIMsg(imsg);
  2512.  
  2513.                 switch( imsgClass )
  2514.                 {
  2515.                     /* Windowschließsymbol gedrückt                */
  2516.                     case IDCMP_CLOSEWINDOW:
  2517.                         CloseBestellenWindow();
  2518.                         break;
  2519.  
  2520.                     /* Gadget gedrückt                                */
  2521.                     case IDCMP_GADGETUP:
  2522.                     case IDCMP_GADGETDOWN:
  2523.                         Done = Abfrage_Gadgetup(gad, imsgCode);
  2524.                         break;
  2525.  
  2526.                     /* Menupunkt ausgewählt                            */
  2527.                     case IDCMP_MENUPICK:
  2528.                         Done = Abfrage_Menuepick(imsgCode);
  2529.                         break;
  2530.  
  2531.                     /* gewähnliche Taste gedrückt                    */
  2532.                     case IDCMP_VANILLAKEY:
  2533.                         Done = Abfrage_Vanillakey( gad, imsgCode);
  2534.                         break;
  2535.  
  2536.                     /* Mauszeiger ruht kurze Zeit über            */
  2537.                     /* einem Gadget => Gadget merken                */
  2538.                     case IDCMP_GADGETHELP:
  2539.                         if( imsg->IAddress == (APTR) BestellenWnd ) 
  2540.                             gd = NULL;
  2541.                         else
  2542.                             gd = gad;
  2543.                         break;
  2544.  
  2545.                     /* Während der Menüauswahl wurde die        */
  2546.                     /* Help-Taste gedrückt                            */
  2547.                     case IDCMP_MENUHELP:
  2548.                         Abfrage_Menuhelp( imsgCode);
  2549.                         break;
  2550.  
  2551.                     /* Steuertaste gedrückt                            */
  2552.                     case IDCMP_RAWKEY:
  2553.                         Abfrage_Rawkey(gad,imsgCode,gd);
  2554.                         break;
  2555.  
  2556.                     /* Irgend was anderes, ignorieren            */
  2557.                     default:
  2558.                         break;
  2559.                 }
  2560.             }
  2561.         }
  2562.  
  2563.         /* Fenster und Bilschirm schließen                        */
  2564.         CloseBestellenWindow();
  2565.         CloseDownScreen();
  2566.  
  2567.         /* Notifycation wieder beenden                            */
  2568.         if( nr )
  2569.             EndNotify(nr);
  2570.  
  2571.         /* Messageport wieder dicht machen                        */
  2572.         if( nmp )
  2573.             DeleteMsgPort(nmp);
  2574.  
  2575.         /* Vector auch wieder freigeben                            */
  2576.         FreeVec(nr);
  2577.  
  2578.         /* Einstellungen speichern                                    */
  2579.         EinstSchreiben();
  2580.  
  2581.         /* Daten speichern und freigeben                            */
  2582.         DatenSchreiben(&vdblist);
  2583.         while( ( n = (struct VDBnode *) RemHead( &vdblist ) ) )
  2584.         {
  2585.             FreeVec(n);
  2586.         }
  2587.         /* Als Commodity abmelden                                    */
  2588.         if ( broker )
  2589.             DeleteCxObj( broker );
  2590.         /* Noch übrige Meldungen abarbeiten                        */
  2591.         while(msg = (CxMsg *)GetMsg(newbroker.nb_Port))
  2592.             ReplyMsg((struct Message *)msg);
  2593.         /* Commodity-Port freigeben                                */
  2594.         if (newbroker.nb_Port)
  2595.             DeletePort(newbroker.nb_Port);
  2596.     }
  2597.     /* Die Librareis konnten nicht (alle) geöffnet werden    */
  2598.     else
  2599.     {
  2600.         /* Nachricht an den User, daß da was nicht stimmt    */
  2601.         printf(AppStrings[MSG_OSError]);
  2602.     }
  2603.     /* geöffnete Libraries wieder schließen                    */
  2604.     CloseAll();
  2605.  
  2606.     /* 0 zurückgeben = alles glattgelaufen                        */
  2607.     return(0);
  2608. }
  2609.